fix merge

Author: lunny

models/repo_branch.go

@@ -14,46 +14,6 @@ import (
 	"github.com/Unknwon/com"
 )
 
-// discardLocalRepoBranchChanges discards local commits/changes of
-// given branch to make sure it is even to remote branch.
-func discardLocalRepoBranchChanges(localPath, branch string) error {
-	if !com.IsExist(localPath) {
-		return nil
-	}
-	// No need to check if nothing in the repository.
-	if !git.IsBranchExist(localPath, branch) {
-		return nil
-	}
-
-	refName := "origin/" + branch
-	if err := git.ResetHEAD(localPath, true, refName); err != nil {
-		return fmt.Errorf("git reset --hard %s: %v", refName, err)
-	}
-	return nil
-}
-
-// DiscardLocalRepoBranchChanges discards the local repository branch changes
-func (repo *Repository) DiscardLocalRepoBranchChanges(branch string) error {
-	return discardLocalRepoBranchChanges(repo.LocalCopyPath(), branch)
-}
-
-// checkoutNewBranch checks out to a new branch from the a branch name.
-func checkoutNewBranch(repoPath, localPath, oldBranch, newBranch string) error {
-	if err := git.Checkout(localPath, git.CheckoutOptions{
-		Timeout:   time.Duration(setting.Git.Timeout.Pull) * time.Second,
-		Branch:    newBranch,
-		OldBranch: oldBranch,
-	}); err != nil {
-		return fmt.Errorf("git checkout -b %s %s: %v", newBranch, oldBranch, err)
-	}
-	return nil
-}
-
-// CheckoutNewBranch checks out a new branch
-func (repo *Repository) CheckoutNewBranch(oldBranch, newBranch string) error {
-	return checkoutNewBranch(repo.RepoPath(), repo.LocalCopyPath(), oldBranch, newBranch)
-}
-
 // Branch holds the branch information
 type Branch struct {
 	Path string

models/repo_editor.go

@@ -6,17 +6,14 @@ package models
 
 import (
 	"fmt"
-	"io"
 	"io/ioutil"
-	"mime/multipart"
 	"os"
 	"os/exec"
 	"path"
 	"path/filepath"
 	"time"
 
 	"github.com/Unknwon/com"
-	gouuid "github.com/satori/go.uuid"
 
 	"code.gitea.io/git"
 
@@ -325,143 +322,6 @@ func (repo *Repository) DeleteRepoFile(doer *User, opts DeleteRepoFileOptions) (
 	return event, nil
 }
 
-//  ____ ___        .__                    .___ ___________.___.__
-// |    |   \______ |  |   _________     __| _/ \_   _____/|   |  |   ____   ______
-// |    |   /\____ \|  |  /  _ \__  \   / __ |   |    __)  |   |  | _/ __ \ /  ___/
-// |    |  / |  |_> >  |_(  <_> ) __ \_/ /_/ |   |     \   |   |  |_\  ___/ \___ \
-// |______/  |   __/|____/\____(____  /\____ |   \___  /   |___|____/\___  >____  >
-//           |__|                   \/      \/       \/                  \/     \/
-//
-
-// Upload represent a uploaded file to a repo to be deleted when moved
-type Upload struct {
-	ID   int64  `xorm:"pk autoincr"`
-	UUID string `xorm:"uuid UNIQUE"`
-	Name string
-}
-
-// UploadLocalPath returns where uploads is stored in local file system based on given UUID.
-func UploadLocalPath(uuid string) string {
-	return path.Join(setting.Repository.Upload.TempPath, uuid[0:1], uuid[1:2], uuid)
-}
-
-// LocalPath returns where uploads are temporarily stored in local file system.
-func (upload *Upload) LocalPath() string {
-	return UploadLocalPath(upload.UUID)
-}
-
-// NewUpload creates a new upload object.
-func NewUpload(name string, buf []byte, file multipart.File) (_ *Upload, err error) {
-	upload := &Upload{
-		UUID: gouuid.NewV4().String(),
-		Name: name,
-	}
-
-	localPath := upload.LocalPath()
-	if err = os.MkdirAll(path.Dir(localPath), os.ModePerm); err != nil {
-		return nil, fmt.Errorf("MkdirAll: %v", err)
-	}
-
-	fw, err := os.Create(localPath)
-	if err != nil {
-		return nil, fmt.Errorf("Create: %v", err)
-	}
-	defer fw.Close()
-
-	if _, err = fw.Write(buf); err != nil {
-		return nil, fmt.Errorf("Write: %v", err)
-	} else if _, err = io.Copy(fw, file); err != nil {
-		return nil, fmt.Errorf("Copy: %v", err)
-	}
-
-	if _, err := x.Insert(upload); err != nil {
-		return nil, err
-	}
-
-	return upload, nil
-}
-
-// GetUploadByUUID returns the Upload by UUID
-func GetUploadByUUID(uuid string) (*Upload, error) {
-	upload := &Upload{UUID: uuid}
-	has, err := x.Get(upload)
-	if err != nil {
-		return nil, err
-	} else if !has {
-		return nil, ErrUploadNotExist{0, uuid}
-	}
-	return upload, nil
-}
-
-// GetUploadsByUUIDs returns multiple uploads by UUIDS
-func GetUploadsByUUIDs(uuids []string) ([]*Upload, error) {
-	if len(uuids) == 0 {
-		return []*Upload{}, nil
-	}
-
-	// Silently drop invalid uuids.
-	uploads := make([]*Upload, 0, len(uuids))
-	return uploads, x.In("uuid", uuids).Find(&uploads)
-}
-
-// DeleteUploads deletes multiple uploads
-func DeleteUploads(uploads ...*Upload) (err error) {
-	if len(uploads) == 0 {
-		return nil
-	}
-
-	sess := x.NewSession()
-	defer sess.Close()
-	if err = sess.Begin(); err != nil {
-		return err
-	}
-
-	ids := make([]int64, len(uploads))
-	for i := 0; i < len(uploads); i++ {
-		ids[i] = uploads[i].ID
-	}
-	if _, err = sess.
-		In("id", ids).
-		Delete(new(Upload)); err != nil {
-		return fmt.Errorf("delete uploads: %v", err)
-	}
-
-	for _, upload := range uploads {
-		localPath := upload.LocalPath()
-		if !com.IsFile(localPath) {
-			continue
-		}
-
-		if err := os.Remove(localPath); err != nil {
-			return fmt.Errorf("remove upload: %v", err)
-		}
-	}
-
-	return sess.Commit()
-}
-
-// DeleteUpload delete a upload
-func DeleteUpload(u *Upload) error {
-	return DeleteUploads(u)
-}
-
-// DeleteUploadByUUID deletes a upload by UUID
-func DeleteUploadByUUID(uuid string) error {
-	upload, err := GetUploadByUUID(uuid)
-	if err != nil {
-		if IsErrUploadNotExist(err) {
-			return nil
-		}
-		return fmt.Errorf("GetUploadByUUID: %v", err)
-	}
-
-	if err := DeleteUpload(upload); err != nil {
-		return fmt.Errorf("DeleteUpload: %v", err)
-	}
-
-	return nil
-}
-
 // UploadRepoFileOptions contains the uploaded repository file options
 type UploadRepoFileOptions struct {
 	LastCommitID string

modules/uploader/delete.go

@@ -21,22 +21,22 @@ type DeleteRepoFileOptions struct {
 }
 
 // DeleteRepoFile deletes a file in the given repository
-func DeleteRepoFile(repo *models.Repository, doer *models.User, opts *DeleteRepoFileOptions) error {
+func DeleteRepoFile(repo *models.Repository, doer *models.User, opts *DeleteRepoFileOptions) (*models.CommitRepoEvent, error) {
 	t, err := NewTemporaryUploadRepository(repo)
 	defer t.Close()
 	if err != nil {
-		return err
+		return nil, err
 	}
 	if err := t.Clone(opts.OldBranch); err != nil {
-		return err
+		return nil, err
 	}
 	if err := t.SetDefaultIndex(); err != nil {
-		return err
+		return nil, err
 	}
 
 	filesInIndex, err := t.LsFiles(opts.TreePath)
 	if err != nil {
-		return fmt.Errorf("UpdateRepoFile: %v", err)
+		return nil, fmt.Errorf("UpdateRepoFile: %v", err)
 	}
 
 	inFilelist := false
@@ -46,28 +46,28 @@ func DeleteRepoFile(repo *models.Repository, doer *models.User, opts *DeleteRepo
 		}
 	}
 	if !inFilelist {
-		return git.ErrNotExist{RelPath: opts.TreePath}
+		return nil, git.ErrNotExist{RelPath: opts.TreePath}
 	}
 
 	if err := t.RemoveFilesFromIndex(opts.TreePath); err != nil {
-		return err
+		return nil, err
 	}
 
 	// Now write the tree
 	treeHash, err := t.WriteTree()
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	// Now commit the tree
 	commitHash, err := t.CommitTree(doer, treeHash, opts.Message)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	// Then push this tree to NewBranch
 	if err := t.Push(doer, commitHash, opts.NewBranch); err != nil {
-		return err
+		return nil, err
 	}
 
 	// Simulate push event.
@@ -77,9 +77,9 @@ func DeleteRepoFile(repo *models.Repository, doer *models.User, opts *DeleteRepo
 	}
 
 	if err = repo.GetOwner(); err != nil {
-		return fmt.Errorf("GetOwner: %v", err)
+		return nil, fmt.Errorf("GetOwner: %v", err)
 	}
-	err = models.PushUpdate(
+	evt, err := models.PushUpdate(
 		opts.NewBranch,
 		models.PushUpdateOptions{
 			PusherID:     doer.ID,
@@ -92,9 +92,9 @@ func DeleteRepoFile(repo *models.Repository, doer *models.User, opts *DeleteRepo
 		},
 	)
 	if err != nil {
-		return fmt.Errorf("PushUpdate: %v", err)
+		return nil, fmt.Errorf("PushUpdate: %v", err)
 	}
 
 	// FIXME: Should we UpdateRepoIndexer(repo) here?
-	return nil
+	return evt, nil
 }