Remote.Fetch base on RefSpec, improvement of the responsabilities separation

14 files changed, 365 insertions, 325 deletions

diff --git a/clients/common/common.go b/clients/common/common.go
index 9099016..d128f3f 100644
--- a/clients/common/common.go
+++ b/clients/common/common.go
@@ -28,6 +28,7 @@ type GitUploadPackService interface {
 	ConnectWithAuth(AuthMethod) error
 	Info() (*GitUploadPackInfo, error)
 	Fetch(*GitUploadPackRequest) (io.ReadCloser, error)
+	Disconnect() error
 }
 
 type AuthMethod interface {
diff --git a/clients/common_test.go b/clients/common_test.go
index 72d8e99..0381f63 100644
--- a/clients/common_test.go
+++ b/clients/common_test.go
@@ -76,6 +76,10 @@ func (s *dummyProtocolService) Fetch(r *common.GitUploadPackRequest) (io.ReadClo
 	return nil, nil
 }
 
+func (s *dummyProtocolService) Disconnect() error {
+	return nil
+}
+
 func typeAsString(v interface{}) string {
 	return fmt.Sprintf("%T", v)
 }
diff --git a/clients/http/git_upload_pack.go b/clients/http/git_upload_pack.go
index 68ec238..79aec3f 100644
--- a/clients/http/git_upload_pack.go
+++ b/clients/http/git_upload_pack.go
@@ -134,3 +134,7 @@ func (s *GitUploadPackService) applyAuthToRequest(req *http.Request) {
 
 	s.auth.setAuth(req)
 }
+
+func (s *GitUploadPackService) Disconnect() (err error) {
+	return nil
+}
diff --git a/common_test.go b/common_test.go
index 3c373ec..386dc74 100644
--- a/common_test.go
+++ b/common_test.go
@@ -2,6 +2,7 @@ package git
 
 import (
 	"bytes"
+	"errors"
 	"io"
 	"io/ioutil"
 	"os"
@@ -21,27 +22,34 @@ type BaseSuite struct{}
 
 func (s *BaseSuite) SetUpTest(c *C) {
 	clients.InstallProtocol("mock", func(end common.Endpoint) common.GitUploadPackService {
-		return &MockGitUploadPackService{conected: end}
+		return &MockGitUploadPackService{endpoint: end}
 	})
 }
 
 const RepositoryFixture = "mock://formats/packfile/fixtures/git-fixture.ref-delta"
 
 type MockGitUploadPackService struct {
-	conected common.Endpoint
-	auth     common.AuthMethod
+	connected bool
+	endpoint  common.Endpoint
+	auth      common.AuthMethod
 }
 
 func (p *MockGitUploadPackService) Connect() error {
+	p.connected = true
 	return nil
 }
 
 func (p *MockGitUploadPackService) ConnectWithAuth(auth common.AuthMethod) error {
+	p.connected = true
 	p.auth = auth
 	return nil
 }
 
 func (p *MockGitUploadPackService) Info() (*common.GitUploadPackInfo, error) {
+	if !p.connected {
+		return nil, errors.New("not connected")
+	}
+
 	h := core.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
 
 	c := common.NewCapabilities()
@@ -62,9 +70,18 @@ func (p *MockGitUploadPackService) Info() (*common.GitUploadPackInfo, error) {
 }
 
 func (p *MockGitUploadPackService) Fetch(*common.GitUploadPackRequest) (io.ReadCloser, error) {
+	if !p.connected {
+		return nil, errors.New("not connected")
+	}
+
 	return os.Open("formats/packfile/fixtures/git-fixture.ref-delta")
 }
 
+func (p *MockGitUploadPackService) Disconnect() error {
+	p.connected = false
+	return nil
+}
+
 type packedFixture struct {
 	url      string
 	packfile string
diff --git a/config/config.go b/config/config.go
new file mode 100644
index 0000000..88172f4
--- /dev/null
+++ b/config/config.go
@@ -0,0 +1,13 @@
+package config
+
+type Config interface {
+	Remote(name string) *RemoteConfig
+	Remotes() []*RemoteConfig
+	SetRemote(*RemoteConfig)
+}
+
+type RemoteConfig struct {
+	Name  string
+	URL   string
+	Fetch RefSpec
+}
diff --git a/config/refspec.go b/config/refspec.go
new file mode 100644
index 0000000..2fe8d22
--- /dev/null
+++ b/config/refspec.go
@@ -0,0 +1,110 @@
+package config
+
+import (
+	"strings"
+
+	"gopkg.in/src-d/go-git.v4/core"
+)
+
+const (
+	refSpecWildcard  = "*"
+	refSpecForce     = "+"
+	refSpecSeparator = ":"
+)
+
+// RefSpec is a mapping from local branches to remote references
+// The format of the refspec is an optional +, followed by <src>:<dst>, where
+// <src> is the pattern for references on the remote side and <dst> is where
+// those references will be written locally. The + tells Git to update the
+// reference even if it isn’t a fast-forward.
+// eg.: "+refs/heads/*:refs/remotes/origin/*"
+//
+// https://git-scm.com/book/es/v2/Git-Internals-The-Refspec
+type RefSpec string
+
+// IsValid validates the RefSpec
+func (s RefSpec) IsValid() bool {
+	spec := string(s)
+	if strings.Count(spec, refSpecSeparator) != 1 {
+		return false
+	}
+
+	sep := strings.Index(spec, refSpecSeparator)
+	if sep == len(spec) {
+		return false
+	}
+
+	ws := strings.Count(spec[0:sep], refSpecWildcard)
+	wd := strings.Count(spec[sep+1:len(spec)], refSpecWildcard)
+	return ws == wd && ws < 2 && wd < 2
+}
+
+// IsForceUpdate returns if update is allowed in non fast-forward merges
+func (s RefSpec) IsForceUpdate() bool {
+	if s[0] == refSpecForce[0] {
+		return true
+	}
+
+	return false
+}
+
+// Src return the src side
+func (s RefSpec) Src() string {
+	spec := string(s)
+	start := strings.Index(spec, refSpecForce) + 1
+	end := strings.Index(spec, refSpecSeparator)
+
+	return spec[start:end]
+}
+
+// Match match the given core.ReferenceName against the source
+func (s RefSpec) Match(n core.ReferenceName) bool {
+	if !s.isGlob() {
+		return s.matchExact(n)
+	}
+
+	return s.matchGlob(n)
+}
+
+func (s RefSpec) isGlob() bool {
+	return strings.Index(string(s), refSpecWildcard) != -1
+}
+
+func (s RefSpec) matchExact(n core.ReferenceName) bool {
+	return s.Src() == n.String()
+}
+
+func (s RefSpec) matchGlob(n core.ReferenceName) bool {
+	src := s.Src()
+	name := n.String()
+	wildcard := strings.Index(src, refSpecWildcard)
+
+	var prefix, suffix string
+	prefix = src[0:wildcard]
+	if len(src) < wildcard {
+		suffix = src[wildcard+1 : len(suffix)]
+	}
+
+	return len(name) > len(prefix)+len(suffix) &&
+		strings.HasPrefix(name, prefix) &&
+		strings.HasSuffix(name, suffix)
+}
+
+// Dst returns the destination for the given remote reference
+func (s RefSpec) Dst(n core.ReferenceName) core.ReferenceName {
+	spec := string(s)
+	start := strings.Index(spec, refSpecSeparator) + 1
+	dst := spec[start:len(spec)]
+	src := s.Src()
+
+	if !s.isGlob() {
+		return core.ReferenceName(dst)
+	}
+
+	name := n.String()
+	ws := strings.Index(src, refSpecWildcard)
+	wd := strings.Index(dst, refSpecWildcard)
+	match := name[ws : len(name)-(len(src)-(ws+1))]
+
+	return core.ReferenceName(dst[0:wd] + match + dst[wd+1:len(dst)])
+}
diff --git a/config/refspec_test.go b/config/refspec_test.go
new file mode 100644
index 0000000..b0bb8f5
--- /dev/null
+++ b/config/refspec_test.go
@@ -0,0 +1,69 @@
+package config
+
+import (
+	"testing"
+
+	. "gopkg.in/check.v1"
+	"gopkg.in/src-d/go-git.v4/core"
+)
+
+type RefSpecSuite struct{}
+
+var _ = Suite(&RefSpecSuite{})
+
+func Test(t *testing.T) { TestingT(t) }
+
+func (s *RefSpecSuite) TestRefSpecIsValid(c *C) {
+	spec := RefSpec("+refs/heads/*:refs/remotes/origin/*")
+	c.Assert(spec.IsValid(), Equals, true)
+
+	spec = RefSpec("refs/heads/*:refs/remotes/origin/")
+	c.Assert(spec.IsValid(), Equals, false)
+
+	spec = RefSpec("refs/heads/master:refs/remotes/origin/master")
+	c.Assert(spec.IsValid(), Equals, true)
+
+	spec = RefSpec("refs/heads/*")
+	c.Assert(spec.IsValid(), Equals, false)
+}
+
+func (s *RefSpecSuite) TestRefSpecIsForceUpdate(c *C) {
+	spec := RefSpec("+refs/heads/*:refs/remotes/origin/*")
+	c.Assert(spec.IsForceUpdate(), Equals, true)
+
+	spec = RefSpec("refs/heads/*:refs/remotes/origin/*")
+	c.Assert(spec.IsForceUpdate(), Equals, false)
+}
+
+func (s *RefSpecSuite) TestRefSpecSrc(c *C) {
+	spec := RefSpec("refs/heads/*:refs/remotes/origin/*")
+	c.Assert(spec.Src(), Equals, "refs/heads/*")
+}
+
+func (s *RefSpecSuite) TestRefSpecMatch(c *C) {
+	spec := RefSpec("refs/heads/master:refs/remotes/origin/master")
+	c.Assert(spec.Match(core.ReferenceName("refs/heads/foo")), Equals, false)
+	c.Assert(spec.Match(core.ReferenceName("refs/heads/master")), Equals, true)
+}
+
+func (s *RefSpecSuite) TestRefSpecMatchBlob(c *C) {
+	spec := RefSpec("refs/heads/*:refs/remotes/origin/*")
+	c.Assert(spec.Match(core.ReferenceName("refs/tag/foo")), Equals, false)
+	c.Assert(spec.Match(core.ReferenceName("refs/heads/foo")), Equals, true)
+}
+
+func (s *RefSpecSuite) TestRefSpecDst(c *C) {
+	spec := RefSpec("refs/heads/master:refs/remotes/origin/master")
+	c.Assert(
+		spec.Dst(core.ReferenceName("refs/heads/master")).String(), Equals,
+		"refs/remotes/origin/master",
+	)
+}
+
+func (s *RefSpecSuite) TestRefSpecDstBlob(c *C) {
+	spec := RefSpec("refs/heads/*:refs/remotes/origin/*")
+	c.Assert(
+		spec.Dst(core.ReferenceName("refs/heads/foo")).String(), Equals,
+		"refs/remotes/origin/foo",
+	)
+}
diff --git a/core/reference.go b/core/reference.go
index 5258146..1325c7e 100644
--- a/core/reference.go
+++ b/core/reference.go
@@ -34,16 +34,12 @@ const (
 // ReferenceName reference name's
 type ReferenceName string
 
-// AsRemote returns a new remote reference name using current one as base
-func (r ReferenceName) AsRemote(remote string) ReferenceName {
-	return ReferenceName(refRemotePrefix + remote + "/" + r.alias())
-}
-
 func (r ReferenceName) String() string {
 	return string(r)
 }
 
-func (r ReferenceName) alias() string {
+// Short returns the short name of a ReferenceName
+func (r ReferenceName) Short() string {
 	parts := strings.Split(string(r), "/")
 	return parts[len(parts)-1]
 }
@@ -114,7 +110,7 @@ func (r *Reference) Target() ReferenceName {
 
 // IsBranch check if a reference is a branch
 func (r *Reference) IsBranch() bool {
-	return strings.HasPrefix(string(r.n), refHeadPrefix) || r.n == HEAD
+	return strings.HasPrefix(string(r.n), refHeadPrefix)
 }
 
 // IsNote check if a reference is a note
@@ -225,107 +221,3 @@ func resolveReference(s ReferenceStorage, r *Reference, recursion int) (*Referen
 	recursion++
 	return resolveReference(s, t, recursion)
 }
-
-const (
-	refSpecWildcard  = "*"
-	refSpecForce     = "+"
-	refSpecSeparator = ":"
-)
-
-// RefSpec is a mapping from local branches to remote references
-// The format of the refspec is an optional +, followed by <src>:<dst>, where
-// <src> is the pattern for references on the remote side and <dst> is where
-// those references will be written locally. The + tells Git to update the
-// reference even if it isn’t a fast-forward.
-// eg.: "+refs/heads/*:refs/remotes/origin/*"
-//
-// https://git-scm.com/book/es/v2/Git-Internals-The-Refspec
-type RefSpec string
-
-// IsValid validates the RefSpec
-func (s RefSpec) IsValid() bool {
-	spec := string(s)
-	if strings.Count(spec, refSpecSeparator) != 1 {
-		return false
-	}
-
-	sep := strings.Index(spec, refSpecSeparator)
-	if sep == len(spec) {
-		return false
-	}
-
-	ws := strings.Count(spec[0:sep], refSpecWildcard)
-	wd := strings.Count(spec[sep+1:len(spec)], refSpecWildcard)
-	return ws == wd && ws < 2 && wd < 2
-}
-
-// IsForceUpdate returns if update is allowed in non fast-forward merges
-func (s RefSpec) IsForceUpdate() bool {
-	if s[0] == refSpecForce[0] {
-		return true
-	}
-
-	return false
-}
-
-// Src return the src side
-func (s RefSpec) Src() string {
-	spec := string(s)
-	start := strings.Index(spec, refSpecForce) + 1
-	end := strings.Index(spec, refSpecSeparator)
-
-	return spec[start:end]
-}
-
-// Match match the given ReferenceName against the source
-func (s RefSpec) Match(n ReferenceName) bool {
-	if !s.isGlob() {
-		return s.matchExact(n)
-	}
-
-	return s.matchGlob(n)
-}
-
-func (s RefSpec) isGlob() bool {
-	return strings.Index(string(s), refSpecWildcard) != -1
-}
-
-func (s RefSpec) matchExact(n ReferenceName) bool {
-	return s.Src() == n.String()
-}
-
-func (s RefSpec) matchGlob(n ReferenceName) bool {
-	src := s.Src()
-	name := n.String()
-	wildcard := strings.Index(src, refSpecWildcard)
-
-	var prefix, suffix string
-	prefix = src[0:wildcard]
-	if len(src) < wildcard {
-		suffix = src[wildcard+1 : len(suffix)]
-	}
-
-	return len(name) > len(prefix)+len(suffix) &&
-		strings.HasPrefix(name, prefix) &&
-		strings.HasSuffix(name, suffix)
-}
-
-// Dst returns the destination for the given remote reference
-func (s RefSpec) Dst(n ReferenceName) ReferenceName {
-	spec := string(s)
-	start := strings.Index(spec, refSpecSeparator) + 1
-	dst := spec[start:len(spec)]
-	src := s.Src()
-
-	if !s.isGlob() {
-		return ReferenceName(dst)
-	}
-
-	name := n.String()
-	ws := strings.Index(src, refSpecWildcard)
-	wd := strings.Index(dst, refSpecWildcard)
-	match := name[ws : len(name)-(len(src)-(ws+1))]
-
-	return ReferenceName(dst[0:wd] + match + dst[wd+1:len(dst)])
-
-}
diff --git a/core/reference_test.go b/core/reference_test.go
index 3d5a9b2..b14f24c 100644
--- a/core/reference_test.go
+++ b/core/reference_test.go
@@ -14,11 +14,8 @@ const (
 	ExampleReferenceName ReferenceName = "refs/heads/v4"
 )
 
-func (s *ReferenceSuite) TestReferenceNameAsRemote(c *C) {
-	c.Assert(
-		ExampleReferenceName.AsRemote("foo").String(),
-		Equals, "refs/remotes/foo/v4",
-	)
+func (s *ReferenceSuite) TestReferenceNameShort(c *C) {
+	c.Assert(ExampleReferenceName.Short(), Equals, "v4")
 }
 
 func (s *ReferenceSuite) TestNewReferenceFromStrings(c *C) {
@@ -121,58 +118,3 @@ func (s *ReferenceSuite) TestReferenceSliceIterForEachStop(c *C) {
 
 	c.Assert(count, Equals, 1)
 }
-
-func (s *ReferenceSuite) TestRefSpecIsValid(c *C) {
-	spec := RefSpec("+refs/heads/*:refs/remotes/origin/*")
-	c.Assert(spec.IsValid(), Equals, true)
-
-	spec = RefSpec("refs/heads/*:refs/remotes/origin/")
-	c.Assert(spec.IsValid(), Equals, false)
-
-	spec = RefSpec("refs/heads/master:refs/remotes/origin/master")
-	c.Assert(spec.IsValid(), Equals, true)
-
-	spec = RefSpec("refs/heads/*")
-	c.Assert(spec.IsValid(), Equals, false)
-}
-
-func (s *ReferenceSuite) TestRefSpecIsForceUpdate(c *C) {
-	spec := RefSpec("+refs/heads/*:refs/remotes/origin/*")
-	c.Assert(spec.IsForceUpdate(), Equals, true)
-
-	spec = RefSpec("refs/heads/*:refs/remotes/origin/*")
-	c.Assert(spec.IsForceUpdate(), Equals, false)
-}
-
-func (s *ReferenceSuite) TestRefSpecSrc(c *C) {
-	spec := RefSpec("refs/heads/*:refs/remotes/origin/*")
-	c.Assert(spec.Src(), Equals, "refs/heads/*")
-}
-
-func (s *ReferenceSuite) TestRefSpecMatch(c *C) {
-	spec := RefSpec("refs/heads/master:refs/remotes/origin/master")
-	c.Assert(spec.Match(ReferenceName("refs/heads/foo")), Equals, false)
-	c.Assert(spec.Match(ReferenceName("refs/heads/master")), Equals, true)
-}
-
-func (s *ReferenceSuite) TestRefSpecMatchBlob(c *C) {
-	spec := RefSpec("refs/heads/*:refs/remotes/origin/*")
-	c.Assert(spec.Match(ReferenceName("refs/tag/foo")), Equals, false)
-	c.Assert(spec.Match(ReferenceName("refs/heads/foo")), Equals, true)
-}
-
-func (s *ReferenceSuite) TestRefSpecDst(c *C) {
-	spec := RefSpec("refs/heads/master:refs/remotes/origin/master")
-	c.Assert(
-		spec.Dst(ReferenceName("refs/heads/master")).String(), Equals,
-		"refs/remotes/origin/master",
-	)
-}
-
-func (s *ReferenceSuite) TestRefSpecDstBlob(c *C) {
-	spec := RefSpec("refs/heads/*:refs/remotes/origin/*")
-	c.Assert(
-		spec.Dst(ReferenceName("refs/heads/foo")).String(), Equals,
-		"refs/remotes/origin/foo",
-	)
-}
diff --git a/options.go b/options.go
index 0c1fefb..414b7f0 100644
--- a/options.go
+++ b/options.go
@@ -2,19 +2,23 @@ package git
 
 import (
 	"errors"
+	"fmt"
 
 	"gopkg.in/src-d/go-git.v3/clients/common"
+	"gopkg.in/src-d/go-git.v4/config"
 	"gopkg.in/src-d/go-git.v4/core"
 )
 
 const (
 	// DefaultRemoteName name of the default Remote, just like git command
-	DefaultRemoteName = "origin"
+	DefaultRemoteName          = "origin"
+	DefaultSingleBranchRefSpec = "+refs/heads/%s:refs/remotes/%s/%[1]s"
+	DefaultRefSpec             = "+refs/heads/*:refs/remotes/%s/*"
 )
 
 var (
-	ErrMissingURL        = errors.New("URL field is required")
-	ErrMissingReferences = errors.New("references cannot be empty")
+	ErrMissingURL     = errors.New("URL field is required")
+	ErrInvalidRefSpec = errors.New("invalid refspec")
 )
 
 // RepositoryCloneOptions describe how a clone should be perform
@@ -50,6 +54,22 @@ func (o *RepositoryCloneOptions) Validate() error {
 	return nil
 }
 
+func (o *RepositoryCloneOptions) refSpec(s core.ReferenceStorage) (config.RefSpec, error) {
+	var spec string
+	if o.SingleBranch {
+		head, err := core.ResolveReference(s, o.ReferenceName)
+		if err != nil {
+			return "", err
+		}
+
+		spec = fmt.Sprintf(DefaultSingleBranchRefSpec, head.Name().Short(), o.RemoteName)
+	} else {
+		spec = fmt.Sprintf(DefaultRefSpec, o.RemoteName)
+	}
+
+	return config.RefSpec(spec), nil
+}
+
 // RepositoryPullOptions describe how a pull should be perform
 type RepositoryPullOptions struct {
 	// Name of the remote to be pulled
@@ -77,18 +97,14 @@ func (o *RepositoryPullOptions) Validate() error {
 
 // RemoteFetchOptions describe how a fetch should be perform
 type RemoteFetchOptions struct {
-	// Remote branchs to fetch
-	References []*core.Reference
-	// Local references present on the local storage
-	LocalReferences []*core.Reference
-	// Limit fetching to the specified number of commits
-	Depth int
+	RefSpec config.RefSpec
+	Depth   int
 }
 
 // Validate validate the fields and set the default values
 func (o *RemoteFetchOptions) Validate() error {
-	if len(o.References) == 0 {
-		return ErrMissingReferences
+	if !o.RefSpec.IsValid() {
+		return ErrInvalidRefSpec
 	}
 
 	return nil
diff --git a/remote.go b/remote.go
index 7e25ef7..9b07223 100644
--- a/remote.go
+++ b/remote.go
@@ -1,14 +1,19 @@
 package git
 
 import (
+	"io"
+
 	"gopkg.in/src-d/go-git.v4/clients"
 	"gopkg.in/src-d/go-git.v4/clients/common"
+	"gopkg.in/src-d/go-git.v4/config"
 	"gopkg.in/src-d/go-git.v4/core"
 	"gopkg.in/src-d/go-git.v4/formats/packfile"
 )
 
 // Remote represents a connection to a remote repository
 type Remote struct {
+	config *config.RemoteConfig
+
 	Name     string
 	Endpoint common.Endpoint
 	Auth     common.AuthMethod
@@ -79,20 +84,19 @@ func (r *Remote) Capabilities() *common.Capabilities {
 }
 
 // Fetch returns a reader using the request
-func (r *Remote) Fetch(s core.ObjectStorage, o *RemoteFetchOptions) (err error) {
+func (r *Remote) Fetch(s core.Storage, o *RemoteFetchOptions) (err error) {
 	if err := o.Validate(); err != nil {
 		return err
 	}
 
-	req := &common.GitUploadPackRequest{}
-	req.Depth = o.Depth
-
-	for _, ref := range o.References {
-		if ref.Type() != core.HashReference {
-			continue
-		}
+	refs, err := r.getWantedReferences(o.RefSpec)
+	if err != nil {
+		return err
+	}
 
-		req.Want(ref.Hash())
+	req, err := r.buildRequest(s.ReferenceStorage(), o, refs)
+	if err != nil {
+		return err
 	}
 
 	reader, err := r.upSrv.Fetch(req)
@@ -101,12 +105,85 @@ func (r *Remote) Fetch(s core.ObjectStorage, o *RemoteFetchOptions) (err error)
 	}
 
 	defer checkClose(reader, &err)
+	if err := r.updateObjectStorage(s.ObjectStorage(), reader); err != nil {
+		return err
+	}
+
+	return r.updateLocalReferenceStorage(s.ReferenceStorage(), o.RefSpec, refs)
+}
+
+func (r *Remote) getWantedReferences(spec config.RefSpec) ([]*core.Reference, error) {
+	var refs []*core.Reference
+
+	return refs, r.Refs().ForEach(func(r *core.Reference) error {
+		if r.Type() != core.HashReference {
+			return nil
+		}
+
+		if spec.Match(r.Name()) {
+			refs = append(refs, r)
+		}
+
+		return nil
+	})
+}
+
+func (r *Remote) buildRequest(
+	s core.ReferenceStorage, o *RemoteFetchOptions, refs []*core.Reference,
+) (*common.GitUploadPackRequest, error) {
+	req := &common.GitUploadPackRequest{}
+	req.Depth = o.Depth
+
+	for _, ref := range refs {
+		req.Want(ref.Hash())
+	}
+
+	i, err := s.Iter()
+	if err != nil {
+		return nil, err
+	}
+
+	err = i.ForEach(func(ref *core.Reference) error {
+		if ref.Type() != core.HashReference {
+			return nil
+		}
+
+		req.Have(ref.Hash())
+		return nil
+	})
+
+	return req, err
+}
+
+func (r *Remote) updateObjectStorage(s core.ObjectStorage, reader io.Reader) error {
 	stream := packfile.NewStream(reader)
 
 	d := packfile.NewDecoder(stream)
 	return d.Decode(s)
 }
 
+func (r *Remote) updateLocalReferenceStorage(
+	local core.ReferenceStorage, spec config.RefSpec, refs []*core.Reference,
+) error {
+	for _, ref := range refs {
+		if !spec.Match(ref.Name()) {
+			continue
+		}
+
+		if ref.Type() != core.HashReference {
+			continue
+		}
+
+		name := spec.Dst(ref.Name())
+		n := core.NewHashReference(name, ref.Hash())
+		if err := local.Set(n); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
 // Head returns the Reference of the HEAD
 func (r *Remote) Head() *core.Reference {
 	return r.upInfo.Head()
@@ -126,3 +203,8 @@ func (r *Remote) Refs() core.ReferenceIter {
 	i, _ := r.upInfo.Refs.Iter()
 	return i
 }
+
+func (r *Remote) Disconnect() error {
+	r.upInfo = nil
+	return r.upSrv.Disconnect()
+}
diff --git a/remote_test.go b/remote_test.go
index c369ab7..451f801 100644
--- a/remote_test.go
+++ b/remote_test.go
@@ -82,17 +82,13 @@ func (s *RemoteSuite) TestFetch(c *C) {
 	c.Assert(err, IsNil)
 	c.Assert(r.Connect(), IsNil)
 
-	sto := memory.NewObjectStorage()
+	sto := memory.NewStorage()
 	err = r.Fetch(sto, &RemoteFetchOptions{
-		References: []*core.Reference{
-			core.NewReferenceFromStrings(
-				"refs/heads/master", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
-			),
-		},
+		RefSpec: DefaultRefSpec,
 	})
 
 	c.Assert(err, IsNil)
-	c.Assert(sto.Objects, HasLen, 28)
+	c.Assert(sto.ObjectStorage().(*memory.ObjectStorage).Objects, HasLen, 28)
 }
 
 func (s *RemoteSuite) TestHead(c *C) {
diff --git a/repository.go b/repository.go
index 676c7b8..ada0bc4 100644
--- a/repository.go
+++ b/repository.go
@@ -11,8 +11,9 @@ import (
 )
 
 var (
-	ErrObjectNotFound = errors.New("object not found")
-	ErrUnknownRemote  = errors.New("unknown remote")
+	ErrObjectNotFound   = errors.New("object not found")
+	ErrUnknownRemote    = errors.New("unknown remote")
+	ErrInvalidReference = errors.New("invalid reference, should be a tag or a branch")
 )
 
 // Repository giturl string, auth common.AuthMethod repository struct
@@ -58,35 +59,28 @@ func (r *Repository) Clone(o *RepositoryCloneOptions) error {
 		return err
 	}
 
-	var single core.ReferenceName
-	if o.SingleBranch {
-		single = o.ReferenceName
-	}
+	defer remote.Disconnect()
 
-	head, err := remote.Ref(o.ReferenceName, true)
+	spec, err := o.refSpec(remote.Info().Refs)
 	if err != nil {
 		return err
 	}
 
-	refs, err := r.getRemoteRefences(remote, single)
-	if err != nil {
-		return err
-	}
-
-	err = remote.Fetch(r.s.ObjectStorage(), &RemoteFetchOptions{
-		References: refs,
-		Depth:      o.Depth,
+	err = remote.Fetch(r.s, &RemoteFetchOptions{
+		RefSpec: spec,
+		Depth:   o.Depth,
 	})
 
 	if err != nil {
 		return err
 	}
 
-	if err := r.createLocalReferences(head); err != nil {
+	head, err := remote.Ref(o.ReferenceName, true)
+	if err != nil {
 		return err
 	}
 
-	return r.createRemoteReferences(remote, refs)
+	return r.createReferences(head)
 }
 
 func (r *Repository) createRemote(name, url string, auth common.AuthMethod) (*Remote, error) {
@@ -99,47 +93,7 @@ func (r *Repository) createRemote(name, url string, auth common.AuthMethod) (*Re
 	return remote, nil
 }
 
-func (r *Repository) getRemoteRefences(
-	remote *Remote, single core.ReferenceName,
-) ([]*core.Reference, error) {
-	if single == "" {
-		return r.getAllRemoteRefences(remote)
-	}
-
-	ref, err := remote.Ref(single, true)
-	if err != nil {
-		return nil, err
-	}
-
-	refs := []*core.Reference{ref}
-	head, err := remote.Ref(core.HEAD, false)
-	if err != nil {
-		return nil, err
-	}
-
-	if head.Target() == ref.Name() {
-		refs = append(refs, head)
-	}
-
-	return refs, nil
-}
-
-func (r *Repository) getAllRemoteRefences(remote *Remote) ([]*core.Reference, error) {
-	var refs []*core.Reference
-	i := remote.Refs()
-	defer i.Close()
-
-	return refs, i.ForEach(func(ref *core.Reference) error {
-		if !ref.IsBranch() {
-			return nil
-		}
-
-		refs = append(refs, ref)
-		return nil
-	})
-}
-
-func (r *Repository) createLocalReferences(ref *core.Reference) error {
+func (r *Repository) createReferences(ref *core.Reference) error {
 	if !ref.IsBranch() {
 		// detached HEAD mode
 		head := core.NewHashReference(core.HEAD, ref.Hash())
@@ -154,38 +108,6 @@ func (r *Repository) createLocalReferences(ref *core.Reference) error {
 	return r.s.ReferenceStorage().Set(head)
 }
 
-func (r *Repository) createRemoteReferences(remote *Remote, remoteRefs []*core.Reference) error {
-	for _, ref := range remoteRefs {
-		if err := r.createRemoteReference(remote, ref); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (r *Repository) createRemoteReference(remote *Remote, ref *core.Reference) error {
-	name := ref.Name().AsRemote(remote.Name)
-
-	var n *core.Reference
-	switch ref.Type() {
-	case core.HashReference:
-		n = core.NewHashReference(name, ref.Hash())
-	case core.SymbolicReference:
-		n = core.NewSymbolicReference(name, ref.Target().AsRemote(remote.Name))
-		target, err := remote.Ref(ref.Target(), false)
-		if err != nil {
-			return err
-		}
-
-		if err := r.createRemoteReference(remote, target); err != nil {
-			return err
-		}
-	}
-
-	return r.s.ReferenceStorage().Set(n)
-}
-
 // Pull incorporates changes from a remote repository into the current branch
 func (r *Repository) Pull(o *RepositoryPullOptions) error {
 	if err := o.Validate(); err != nil {
@@ -202,37 +124,21 @@ func (r *Repository) Pull(o *RepositoryPullOptions) error {
 		return err
 	}
 
-	refs, err := r.getLocalReferences()
-	if err != nil {
+	if err = remote.Connect(); err != nil {
 		return err
 	}
 
-	err = remote.Fetch(r.s.ObjectStorage(), &RemoteFetchOptions{
-		References:      []*core.Reference{head},
-		LocalReferences: refs,
-		Depth:           o.Depth,
+	defer remote.Disconnect()
+
+	err = remote.Fetch(r.s, &RemoteFetchOptions{
+		Depth: o.Depth,
 	})
 
 	if err != nil {
 		return err
 	}
 
-	return r.createLocalReferences(head)
-}
-
-func (r *Repository) getLocalReferences() ([]*core.Reference, error) {
-	var refs []*core.Reference
-	i := r.Refs()
-	defer i.Close()
-
-	return refs, i.ForEach(func(ref *core.Reference) error {
-		if ref.Type() == core.SymbolicReference {
-			return nil
-		}
-
-		refs = append(refs, ref)
-		return nil
-	})
+	return r.createReferences(head)
 }
 
 // Commit return the commit with the given hash
diff --git a/repository_test.go b/repository_test.go
index c2b2ff2..2539a0b 100644
--- a/repository_test.go
+++ b/repository_test.go
@@ -95,12 +95,6 @@ func (s *RepositorySuite) TestClone(c *C) {
 	c.Assert(branch, NotNil)
 	c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
 
-	branch, err = r.Ref("refs/remotes/origin/HEAD", false)
-	c.Assert(err, IsNil)
-	c.Assert(branch, NotNil)
-	c.Assert(branch.Type(), Equals, core.SymbolicReference)
-	c.Assert(branch.Target().String(), Equals, "refs/remotes/origin/master")
-
 	branch, err = r.Ref("refs/remotes/origin/master", false)
 	c.Assert(err, IsNil)
 	c.Assert(branch, NotNil)
@@ -182,12 +176,6 @@ func (s *RepositorySuite) TestCloneSingleBranch(c *C) {
 	c.Assert(branch, NotNil)
 	c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
 
-	branch, err = r.Ref("refs/remotes/origin/HEAD", false)
-	c.Assert(err, IsNil)
-	c.Assert(branch, NotNil)
-	c.Assert(branch.Type(), Equals, core.SymbolicReference)
-	c.Assert(branch.Target().String(), Equals, "refs/remotes/origin/master")
-
 	branch, err = r.Ref("refs/remotes/origin/master", false)
 	c.Assert(err, IsNil)
 	c.Assert(branch, NotNil)