Merge pull request #16 from github/dont-join-abs

NewRepository: don't join paths if `gitDir` is already absolute

Author: mhagger

git/git.go

@@ -65,11 +65,8 @@ type Repository struct {
 }
 
 func NewRepository(path string) (*Repository, error) {
-	command := exec.Command(
-		"git", "-C", path,
-		"rev-parse", "--git-dir",
-	)
-	out, err := command.Output()
+	cmd := exec.Command("git", "-C", path, "rev-parse", "--git-dir")
+	out, err := cmd.Output()
 	if err != nil {
 		switch err := err.(type) {
 		case *exec.Error:
@@ -90,13 +87,22 @@ func NewRepository(path string) (*Repository, error) {
 			return nil, err
 		}
 	}
-	gitDir := filepath.Join(path, string(bytes.TrimSpace(out)))
+	gitDir := string(bytes.TrimSpace(out))
+	if !filepath.IsAbs(gitDir) {
+		gitDir = filepath.Join(path, gitDir)
+	}
 	repo := &Repository{
 		path: gitDir,
 	}
 	return repo, nil
 }
 
+func (repo *Repository) gitCommand(args ...string) *exec.Cmd {
+	cmd := exec.Command("git", args...)
+	cmd.Env = append(os.Environ(), "GIT_DIR="+repo.path)
+	return cmd
+}
+
 func (repo *Repository) Path() string {
 	return repo.path
 }
@@ -113,7 +119,7 @@ type Reference struct {
 }
 
 type ReferenceIter struct {
-	command *exec.Cmd
+	cmd     *exec.Cmd
 	out     io.ReadCloser
 	f       *bufio.Reader
 	errChan <-chan error
@@ -122,25 +128,24 @@ type ReferenceIter struct {
 // NewReferenceIter returns an iterator that iterates over all of the
 // references in `repo`.
 func (repo *Repository) NewReferenceIter() (*ReferenceIter, error) {
-	command := exec.Command(
-		"git", "-C", repo.path,
+	cmd := repo.gitCommand(
 		"for-each-ref", "--format=%(objectname) %(objecttype) %(objectsize) %(refname)",
 	)
 
-	out, err := command.StdoutPipe()
+	out, err := cmd.StdoutPipe()
 	if err != nil {
 		return nil, err
 	}
 
-	command.Stderr = os.Stderr
+	cmd.Stderr = os.Stderr
 
-	err = command.Start()
+	err = cmd.Start()
 	if err != nil {
 		return nil, err
 	}
 
 	return &ReferenceIter{
-		command: command,
+		cmd:     cmd,
 		out:     out,
 		f:       bufio.NewReader(out),
 		errChan: make(chan error, 1),
@@ -180,49 +185,46 @@ func (iter *ReferenceIter) Next() (Reference, bool, error) {
 
 func (l *ReferenceIter) Close() error {
 	err := l.out.Close()
-	err2 := l.command.Wait()
+	err2 := l.cmd.Wait()
 	if err == nil {
 		err = err2
 	}
 	return err
 }
 
 type BatchObjectIter struct {
-	command *exec.Cmd
-	out     io.ReadCloser
-	f       *bufio.Reader
+	cmd *exec.Cmd
+	out io.ReadCloser
+	f   *bufio.Reader
 }
 
 // NewBatchObjectIter returns iterates over objects whose names are
 // fed into its stdin. The output is buffered, so it has to be closed
 // before you can be sure to read all of the objects.
 func (repo *Repository) NewBatchObjectIter() (*BatchObjectIter, io.WriteCloser, error) {
-	command := exec.Command(
-		"git", "-C", repo.path,
-		"cat-file", "--batch", "--buffer",
-	)
+	cmd := repo.gitCommand("cat-file", "--batch", "--buffer")
 
-	in, err := command.StdinPipe()
+	in, err := cmd.StdinPipe()
 	if err != nil {
 		return nil, nil, err
 	}
 
-	out, err := command.StdoutPipe()
+	out, err := cmd.StdoutPipe()
 	if err != nil {
 		return nil, nil, err
 	}
 
-	command.Stderr = os.Stderr
+	cmd.Stderr = os.Stderr
 
-	err = command.Start()
+	err = cmd.Start()
 	if err != nil {
 		return nil, nil, err
 	}
 
 	return &BatchObjectIter{
-		command: command,
-		out:     out,
-		f:       bufio.NewReader(out),
+		cmd: cmd,
+		out: out,
+		f:   bufio.NewReader(out),
 	}, in, nil
 }
 
@@ -247,7 +249,7 @@ func (iter *BatchObjectIter) Next() (OID, ObjectType, counts.Count32, []byte, er
 
 func (l *BatchObjectIter) Close() error {
 	err := l.out.Close()
-	err2 := l.command.Wait()
+	err2 := l.cmd.Wait()
 	if err == nil {
 		err = err2
 	}
@@ -355,13 +357,13 @@ func parseBatchHeader(spec string, header string) (OID, ObjectType, counts.Count
 }
 
 type ObjectIter struct {
-	command1 *exec.Cmd
-	command2 *exec.Cmd
-	in1      io.Writer
-	out1     io.ReadCloser
-	out2     io.ReadCloser
-	f        *bufio.Reader
-	errChan  <-chan error
+	cmd1    *exec.Cmd
+	cmd2    *exec.Cmd
+	in1     io.Writer
+	out1    io.ReadCloser
+	out2    io.ReadCloser
+	f       *bufio.Reader
+	errChan <-chan error
 }
 
 // NewObjectIter returns an iterator that iterates over objects in
@@ -371,49 +373,43 @@ type ObjectIter struct {
 func (repo *Repository) NewObjectIter(args ...string) (
 	*ObjectIter, io.WriteCloser, error,
 ) {
-	cmdArgs := []string{"-C", repo.path, "rev-list", "--objects"}
-	cmdArgs = append(cmdArgs, args...)
-	command1 := exec.Command("git", cmdArgs...)
-	in1, err := command1.StdinPipe()
+	cmd1 := repo.gitCommand(append([]string{"rev-list", "--objects"}, args...)...)
+	in1, err := cmd1.StdinPipe()
 	if err != nil {
 		return nil, nil, err
 	}
 
-	out1, err := command1.StdoutPipe()
+	out1, err := cmd1.StdoutPipe()
 	if err != nil {
 		return nil, nil, err
 	}
 
-	command1.Stderr = os.Stderr
+	cmd1.Stderr = os.Stderr
 
-	err = command1.Start()
+	err = cmd1.Start()
 	if err != nil {
 		return nil, nil, err
 	}
 
-	command2 := exec.Command(
-		"git", "-C", repo.path,
-		"cat-file", "--batch-check", "--buffer",
-	)
-
-	in2, err := command2.StdinPipe()
+	cmd2 := repo.gitCommand("cat-file", "--batch-check", "--buffer")
+	in2, err := cmd2.StdinPipe()
 	if err != nil {
 		out1.Close()
-		command1.Wait()
+		cmd1.Wait()
 		return nil, nil, err
 	}
 
-	out2, err := command2.StdoutPipe()
+	out2, err := cmd2.StdoutPipe()
 	if err != nil {
 		in2.Close()
 		out1.Close()
-		command1.Wait()
+		cmd1.Wait()
 		return nil, nil, err
 	}
 
-	command2.Stderr = os.Stderr
+	cmd2.Stderr = os.Stderr
 
-	err = command2.Start()
+	err = cmd2.Start()
 	if err != nil {
 		return nil, nil, err
 	}
@@ -444,23 +440,20 @@ func (repo *Repository) NewObjectIter(args ...string) (
 	}()
 
 	return &ObjectIter{
-		command1: command1,
-		command2: command2,
-		out1:     out1,
-		out2:     out2,
-		f:        bufio.NewReader(out2),
-		errChan:  errChan,
+		cmd1:    cmd1,
+		cmd2:    cmd2,
+		out1:    out1,
+		out2:    out2,
+		f:       bufio.NewReader(out2),
+		errChan: errChan,
 	}, in1, nil
 }
 
 // CreateObject creates a new Git object, of the specified type, in
 // `Repository`. `writer` is a function that writes the object in `git
 // hash-object` input format. This is used for testing only.
 func (repo *Repository) CreateObject(t ObjectType, writer func(io.Writer) error) (OID, error) {
-	cmd := exec.Command(
-		"git", "-C", repo.path,
-		"hash-object", "-w", "-t", string(t), "--stdin",
-	)
+	cmd := repo.gitCommand("hash-object", "-w", "-t", string(t), "--stdin")
 	in, err := cmd.StdinPipe()
 	if err != nil {
 		return OID{}, err
@@ -505,15 +498,9 @@ func (repo *Repository) UpdateRef(refname string, oid OID) error {
 	var cmd *exec.Cmd
 
 	if oid == NullOID {
-		cmd = exec.Command(
-			"git", "-C", repo.path,
-			"update-ref", "-d", refname,
-		)
+		cmd = repo.gitCommand("update-ref", "-d", refname)
 	} else {
-		cmd = exec.Command(
-			"git", "-C", repo.path,
-			"update-ref", refname, oid.String(),
-		)
+		cmd = repo.gitCommand("update-ref", refname, oid.String())
 	}
 	return cmd.Run()
 }
@@ -532,11 +519,11 @@ func (l *ObjectIter) Close() error {
 	l.out1.Close()
 	err := <-l.errChan
 	l.out2.Close()
-	err2 := l.command1.Wait()
+	err2 := l.cmd1.Wait()
 	if err == nil {
 		err = err2
 	}
-	err2 = l.command2.Wait()
+	err2 = l.cmd2.Wait()
 	if err == nil {
 		err = err2
 	}