Merge pull request #438 from john-cai/jc/commit-ammend

Add Amend option to CommitOptions

options.go

···
 	// commit will not be signed. The private key must be present and already
 	// decrypted.
 	SignKey *openpgp.Entity
+	// Amend will create a new commit object and replace the commit that HEAD currently
+	// points to. Cannot be used with All nor Parents.
+	Amend bool
 }
 
 // Validate validates the fields and sets the default values.
 func (o *CommitOptions) Validate(r *Repository) error {
+	if o.All && o.Amend {
+		return errors.New("all and amend cannot be used together")
+	}
+
+	if o.Amend && len(o.Parents) > 0 {
+		return errors.New("parents cannot be used with amend")
+	}
+
 	if o.Author == nil {
 		if err := o.loadConfigAuthorAndCommitter(r); err != nil {
 			return err

worktree_commit.go

···
 		}
 	}
 
-	idx, err := w.r.Storer.Index()
-	if err != nil {
-		return plumbing.ZeroHash, err
-	}
+	var treeHash plumbing.Hash
+
+	if opts.Amend {
+		head, err := w.r.Head()
+		if err != nil {
+			return plumbing.ZeroHash, err
+		}
+
+		t, err := w.r.getTreeFromCommitHash(head.Hash())
+		if err != nil {
+			return plumbing.ZeroHash, err
+		}
+
+		treeHash = t.Hash
+		opts.Parents = []plumbing.Hash{head.Hash()}
+	} else {
+		idx, err := w.r.Storer.Index()
+		if err != nil {
+			return plumbing.ZeroHash, err
+		}
 
-	h := &buildTreeHelper{
-		fs: w.Filesystem,
-		s:  w.r.Storer,
-	}
+		h := &buildTreeHelper{
+			fs: w.Filesystem,
+			s:  w.r.Storer,
+		}
 
-	tree, err := h.BuildTree(idx, opts)
-	if err != nil {
-		return plumbing.ZeroHash, err
+		treeHash, err = h.BuildTree(idx, opts)
+		if err != nil {
+			return plumbing.ZeroHash, err
+		}
 	}
 
-	commit, err := w.buildCommitObject(msg, opts, tree)
+	commit, err := w.buildCommitObject(msg, opts, treeHash)
 	if err != nil {
 		return plumbing.ZeroHash, err
 	}
···
 		return hash, nil
 	}
 	return h.s.SetEncodedObject(o)
-}
+}

worktree_commit_test.go

···
 	assertStorageStatus(c, s.Repository, 13, 11, 10, expected)
 }
 
+func (s *WorktreeSuite) TestCommitAmend(c *C) {
+	fs := memfs.New()
+	w := &Worktree{
+		r:          s.Repository,
+		Filesystem: fs,
+	}
+
+	err := w.Checkout(&CheckoutOptions{})
+	c.Assert(err, IsNil)
+
+	util.WriteFile(fs, "foo", []byte("foo"), 0644)
+
+	_, err = w.Add("foo")
+	c.Assert(err, IsNil)
+
+	_, err = w.Commit("foo\n", &CommitOptions{Author: defaultSignature()})
+	c.Assert(err, IsNil)
+
+
+	amendedHash, err := w.Commit("bar\n", &CommitOptions{Amend: true})
+	c.Assert(err, IsNil)
+
+	headRef, err := w.r.Head()
+	c.Assert(amendedHash, Equals, headRef.Hash())
+	commit, err := w.r.CommitObject(headRef.Hash())
+	c.Assert(err, IsNil)
+	c.Assert(commit.Message, Equals, "bar\n")
+
+	assertStorageStatus(c, s.Repository, 13, 11, 11, amendedHash)
+}
+
 func (s *WorktreeSuite) TestCommitAll(c *C) {
 	expected := plumbing.NewHash("aede6f8c9c1c7ec9ca8d287c64b8ed151276fa28")