complete migration from gogs module

Author: unknwon

commit.go

@@ -5,7 +5,10 @@
 package git
 
 import (
+	"bufio"
+	"container/list"
 	"fmt"
+	"net/http"
 	"strconv"
 	"strings"
 
@@ -20,8 +23,18 @@ type Commit struct {
 	Committer     *Signature
 	CommitMessage string
 
-	parents []sha1 // SHA1 strings
-	// submodules map[string]*SubModule
+	parents    []sha1 // SHA1 strings
+	submodules map[string]*SubModule
+}
+
+// Message returns the commit message. Same as retrieving CommitMessage directly.
+func (c *Commit) Message() string {
+	return c.CommitMessage
+}
+
+// Summary returns first line of commit message.
+func (c *Commit) Summary() string {
+	return strings.Split(c.CommitMessage, "\n")[0]
 }
 
 // ParentID returns oid of n-th parent (0-based index).
@@ -47,14 +60,41 @@ func (c *Commit) Parent(n int) (*Commit, error) {
 }
 
 // ParentCount returns number of parents of the commit.
-// 0 if this is the root commit, otherwise 1,2, etc.
+// 0 if this is the root commit,  otherwise 1,2, etc.
 func (c *Commit) ParentCount() int {
 	return len(c.parents)
 }
 
-// GetCommitOfRelPath return the commit of relative path object.
-func (c *Commit) GetCommitOfRelPath(relpath string) (*Commit, error) {
-	return c.repo.getCommitOfRelPath(c.ID, relpath)
+func isImageFile(data []byte) (string, bool) {
+	contentType := http.DetectContentType(data)
+	if strings.Index(contentType, "image/") != -1 {
+		return contentType, true
+	}
+	return contentType, false
+}
+
+func (c *Commit) IsImageFile(name string) bool {
+	blob, err := c.GetBlobByPath(name)
+	if err != nil {
+		return false
+	}
+
+	dataRc, err := blob.Data()
+	if err != nil {
+		return false
+	}
+	buf := make([]byte, 1024)
+	n, _ := dataRc.Read(buf)
+	if n > 0 {
+		buf = buf[:n]
+	}
+	_, isImage := isImageFile(buf)
+	return isImage
+}
+
+// GetCommitByPath return the commit of relative path object.
+func (c *Commit) GetCommitByPath(relpath string) (*Commit, error) {
+	return c.repo.getCommitByPathWithID(c.ID, relpath)
 }
 
 // AddAllChanges marks local changes to be ready for commit.
@@ -82,19 +122,102 @@ func CommitChanges(repoPath, message string, author *Signature) error {
 	return err
 }
 
-// CommitsCount returns number of total commits of until given revision.
-func CommitsCount(repoPath, revision string) (int64, error) {
+func commitsCount(repoPath, revision, relpath string) (int64, error) {
+	var cmd *Command
+	isFallback := false
 	if version.Compare(gitVersion, "1.8.0", "<") {
-		stdout, err := NewCommand("log", "--pretty=format:''", revision).RunInDir(repoPath)
-		if err != nil {
-			return 0, err
-		}
-		return int64(len(strings.Split(stdout, "\n"))), nil
+		isFallback = true
+		cmd = NewCommand("log", "--pretty=format:''")
+	} else {
+		cmd = NewCommand("rev-list", "--count")
+	}
+	cmd.AddArguments(revision)
+	if len(relpath) > 0 {
+		cmd.AddArguments("--", relpath)
 	}
 
-	stdout, err := NewCommand("rev-list", "--count", revision).RunInDir(repoPath)
+	stdout, err := cmd.RunInDir(repoPath)
 	if err != nil {
 		return 0, err
 	}
+
+	if isFallback {
+		return int64(len(strings.Split(stdout, "\n"))), nil
+	}
 	return strconv.ParseInt(strings.TrimSpace(stdout), 10, 64)
 }
+
+// CommitsCount returns number of total commits of until given revision.
+func CommitsCount(repoPath, revision string) (int64, error) {
+	return commitsCount(repoPath, revision, "")
+}
+
+func (c *Commit) CommitsCount() (int64, error) {
+	return CommitsCount(c.repo.Path, c.ID.String())
+}
+
+func (c *Commit) CommitsByRange(page int) (*list.List, error) {
+	return c.repo.commitsByRange(c.ID, page)
+}
+
+func (c *Commit) CommitsBefore() (*list.List, error) {
+	return c.repo.getCommitsBefore(c.ID)
+}
+
+func (c *Commit) CommitsBeforeUntil(commitID string) (*list.List, error) {
+	endCommit, err := c.repo.GetCommit(commitID)
+	if err != nil {
+		return nil, err
+	}
+	return c.repo.CommitsBetween(c, endCommit)
+}
+
+func (c *Commit) SearchCommits(keyword string) (*list.List, error) {
+	return c.repo.searchCommits(c.ID, keyword)
+}
+
+func (c *Commit) GetSubModule(entryname string) (*SubModule, error) {
+	modules, err := c.GetSubModules()
+	if err != nil {
+		return nil, err
+	}
+	return modules[entryname], nil
+}
+
+func (c *Commit) GetSubModules() (map[string]*SubModule, error) {
+	if c.submodules != nil {
+		return c.submodules, nil
+	}
+
+	entry, err := c.GetTreeEntryByPath(".gitmodules")
+	if err != nil {
+		return nil, err
+	}
+	rd, err := entry.Blob().Data()
+	if err != nil {
+		return nil, err
+	}
+
+	scanner := bufio.NewScanner(rd)
+	c.submodules = make(map[string]*SubModule)
+	var ismodule bool
+	var path string
+	for scanner.Scan() {
+		if strings.HasPrefix(scanner.Text(), "[submodule") {
+			ismodule = true
+			continue
+		}
+		if ismodule {
+			fields := strings.Split(scanner.Text(), "=")
+			k := strings.TrimSpace(fields[0])
+			if k == "path" {
+				path = strings.TrimSpace(fields[1])
+			} else if k == "url" {
+				c.submodules[path] = &SubModule{path, strings.TrimSpace(fields[1])}
+				ismodule = false
+			}
+		}
+	}
+
+	return c.submodules, nil
+}

commit_archive.go

@@ -0,0 +1,29 @@
+// Copyright 2015 The Gogs Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package git
+
+import "fmt"
+
+type ArchiveType int
+
+const (
+	ZIP ArchiveType = iota + 1
+	TARGZ
+)
+
+func (c *Commit) CreateArchive(path string, archiveType ArchiveType) error {
+	var format string
+	switch archiveType {
+	case ZIP:
+		format = "zip"
+	case TARGZ:
+		format = "tar.gz"
+	default:
+		return fmt.Errorf("unknown format: %v", archiveType)
+	}
+
+	_, err := NewCommand("archive", "--format="+format, "-o", path, c.ID.String()).RunInDir(c.repo.Path)
+	return err
+}

error.go

@@ -35,3 +35,16 @@ func IsErrNotExist(err error) bool {
 func (err ErrNotExist) Error() string {
 	return fmt.Sprintf("object does not exist [id: %s, rel_path: %s]", err.ID, err.RelPath)
 }
+
+type ErrUnsupportedVersion struct {
+	Required string
+}
+
+func IsErrUnsupportedVersion(err error) bool {
+	_, ok := err.(ErrUnsupportedVersion)
+	return ok
+}
+
+func (err ErrUnsupportedVersion) Error() string {
+	return fmt.Sprintf("Operation requires higher version [required: %s]", err.Required)
+}

git.go

@@ -10,6 +10,12 @@ import (
 	"time"
 )
 
+const _VERSION = "0.1.0"
+
+func Version() string {
+	return _VERSION
+}
+
 var (
 	// Debug enables verbose logging on everything.
 	// This should be false in case Gogs starts in SSH mode.
@@ -33,7 +39,7 @@ func log(format string, args ...interface{}) {
 var gitVersion string
 
 // Version returns current Git version from shell.
-func Version() (string, error) {
+func BinVersion() (string, error) {
 	if len(gitVersion) > 0 {
 		return gitVersion, nil
 	}
@@ -53,7 +59,7 @@ func Version() (string, error) {
 }
 
 func init() {
-	Version()
+	BinVersion()
 }
 
 // Fsck verifies the connectivity and validity of the objects in the database

hook.go

@@ -0,0 +1,127 @@
+// Copyright 2015 The Gogs Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package git
+
+import (
+	"errors"
+	"io/ioutil"
+	"os"
+	"path"
+	"strings"
+)
+
+// hookNames is a list of Git hooks' name that are supported.
+var hookNames = []string{
+	"applypatch-msg",
+	"pre-applypatch",
+	"post-applypatch",
+	"pre-commit",
+	"prepare-commit-msg",
+	"commit-msg",
+	"post-commit",
+	"pre-rebase",
+	"post-checkout",
+	"post-merge",
+	"pre-push",
+	"pre-receive",
+	// "update",
+	"post-receive",
+	"post-update",
+	"push-to-checkout",
+	"pre-auto-gc",
+	"post-rewrite",
+}
+
+var (
+	ErrNotValidHook = errors.New("not a valid Git hook")
+)
+
+// IsValidHookName returns true if given name is a valid Git hook.
+func IsValidHookName(name string) bool {
+	for _, hn := range hookNames {
+		if hn == name {
+			return true
+		}
+	}
+	return false
+}
+
+// Hook represents a Git hook.
+type Hook struct {
+	name     string
+	IsActive bool   // Indicates whether repository has this hook.
+	Content  string // Content of hook if it's active.
+	Sample   string // Sample content from Git.
+	path     string // Hook file path.
+}
+
+// GetHook returns a Git hook by given name and repository.
+func GetHook(repoPath, name string) (*Hook, error) {
+	if !IsValidHookName(name) {
+		return nil, ErrNotValidHook
+	}
+	h := &Hook{
+		name: name,
+		path: path.Join(repoPath, "hooks", name),
+	}
+	if isFile(h.path) {
+		data, err := ioutil.ReadFile(h.path)
+		if err != nil {
+			return nil, err
+		}
+		h.IsActive = true
+		h.Content = string(data)
+	} else if isFile(h.path + ".sample") {
+		data, err := ioutil.ReadFile(h.path + ".sample")
+		if err != nil {
+			return nil, err
+		}
+		h.Sample = string(data)
+	}
+	return h, nil
+}
+
+func (h *Hook) Name() string {
+	return h.name
+}
+
+// Update updates hook settings.
+func (h *Hook) Update() error {
+	if len(strings.TrimSpace(h.Content)) == 0 {
+		if isExist(h.path) {
+			return os.Remove(h.path)
+		}
+		return nil
+	}
+	return ioutil.WriteFile(h.path, []byte(strings.Replace(h.Content, "\r", "", -1)), os.ModePerm)
+}
+
+// ListHooks returns a list of Git hooks of given repository.
+func ListHooks(repoPath string) (_ []*Hook, err error) {
+	if !isDir(path.Join(repoPath, "hooks")) {
+		return nil, errors.New("hooks path does not exist")
+	}
+
+	hooks := make([]*Hook, len(hookNames))
+	for i, name := range hookNames {
+		hooks[i], err = GetHook(repoPath, name)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return hooks, nil
+}
+
+const (
+	HOOK_PATH_UPDATE = "hooks/update"
+)
+
+// SetUpdateHook writes given content to update hook of the reposiotry.
+func SetUpdateHook(repoPath, content string) error {
+	log("Setting update hook: %s", repoPath)
+	hookPath := path.Join(repoPath, HOOK_PATH_UPDATE)
+	os.MkdirAll(path.Dir(hookPath), os.ModePerm)
+	return ioutil.WriteFile(hookPath, []byte(content), 0777)
+}