Merge pull request #96 from bctnry/master

feat: basic file editing ui

Author: bctnry

docs/single-file-update.org

@@ -0,0 +1,43 @@
+* single file update
+
+currently aegis uses git-fast-import. the process consists of two commands:
+
++ =git fast-import --date-format=now --quiet=
+  + we send the payload to its stdin.
+  + we read the content of its stdout.
++ =git update-ref [ref-full-name] [commit-id]=
+  + =[ref-full-name]= are the ones that starts with =refs/heads/=, like =refs/heads/master=.
+  + =[commit-id]= comes from the stdout from the first command.
+
+** how =git-fast-import= is used
+
+#+begin_src
+commit [ref-full-name]
+mark :1
+author [user-full-name] <[user-email]> now
+committer [user-full-name] <[user-email> now
+data <<%
+[commit message]
+%
+from [ref-full-name]^0
+M [mode] inline [path]
+data <<%
+data
+%
+
+get-mark :1
+#+end_src
+
+according to [[https://git-scm.com/docs/git-fast-import][git-fast-import's documentation]]:
+
++ the =commit= line specifies the branch the new commit needs to be made on.
++ =mark= marks the commit. we need to add a mark here so we can retrieve the id of new commit with =get-mark= command at the last.
++ the next 3 command is for specifying the author, the committer and the commit message.
+  + if you need to add a signature, you need to use the separate =gpgsig= command instead of appending the signature to the commit message, since unlike co-authored-by, gpg signature and commit messages are different slots in a commit object.
++ the =from= command is used to specify the parent commit of the created commit. use =[ref-full-name]^0= to specify the latest commit of the branch.
++ the line with =M= is a filemodify command that specifies the creation of a new file or a modification of an existing one.
+  + if you use =inline= you need to use a =data= command to specify the data of the resulting file.
+  + instead of using =inline= in the =M= command, one can first add the resulting file into the repository as a blob and do =M [mode] [blob-id] [path]= instead.
+
+the =data= command has two forms which I will not describe here. currently aegis use the "delimited" form for commit message and "length-specified" form for text data, since delimited form cannot describe data that doesn't end with line feed.
+

pkg/aegis/model/acl.go

@@ -15,6 +15,7 @@ type ACLTuple struct {
 	ArchiveRepository bool `json:"archiveRepo"`
 	DeleteRepository bool `json:"deleteRepo"`
 	EditHooks bool `json:"editHooks"`
+	EditWebHooks bool `json:"editWebHooks"`
 }
 
 type ACL struct {
@@ -26,7 +27,7 @@ func (aclt *ACLTuple) HasSettingPrivilege() bool {
 	if aclt == nil { return false }
 	// NOTE THAT having PushToRepository permission does not mean a
 	// user is allowed to go into the setting panels of things.
-	return aclt.AddMember || aclt.DeleteMember || aclt.EditMember || aclt.AddRepository || aclt.EditInfo || aclt.ArchiveRepository || aclt.DeleteRepository || aclt.EditHooks
+	return aclt.AddMember || aclt.DeleteMember || aclt.EditMember || aclt.AddRepository || aclt.EditInfo || aclt.ArchiveRepository || aclt.DeleteRepository || aclt.EditHooks || aclt.EditWebHooks
 }
 
 func NewACL() *ACL {
@@ -69,6 +70,7 @@ func ToCommaSeparatedString(aclt *ACLTuple) string {
 	if aclt.ArchiveRepository { res = append(res, "archiveRepo") }
 	if aclt.DeleteRepository { res = append(res, "deleteRepo") }
 	if aclt.EditHooks { res = append(res, "editHooks") }
+	if aclt.EditWebHooks { res = append(res, "editWebHooks") }
 	return strings.Join(res, ",")
 }
 

routes/aux.go

@@ -82,6 +82,8 @@ func GenerateLoginInfoModel(ctx *RouterContext, r *http.Request) (*templates.Log
 		return &templates.LoginInfoModel{
 			LoggedIn: loggedIn,
 			UserName: "",
+			UserFullName: "",
+			UserEmail: "",
 			IsOwner: false,
 			IsSettingMember: false,
 			IsAdmin: false,
@@ -94,6 +96,8 @@ func GenerateLoginInfoModel(ctx *RouterContext, r *http.Request) (*templates.Log
 		return &templates.LoginInfoModel{
 			LoggedIn: loggedIn,
 			UserName: "",
+			UserFullName: "",
+			UserEmail: "",
 			IsOwner: false,
 			IsSettingMember: false,
 			IsAdmin: false,
@@ -107,6 +111,8 @@ func GenerateLoginInfoModel(ctx *RouterContext, r *http.Request) (*templates.Log
 	return &templates.LoginInfoModel{
 		LoggedIn: res,
 		UserName: un,
+		UserFullName: u.Title,
+		UserEmail: u.Email,
 		IsOwner: false,
 		IsSettingMember: false,
 		IsAdmin: u.Status == model.ADMIN || u.Status == model.SUPER_ADMIN,

routes/context.go

@@ -5,19 +5,20 @@ package routes
 // together and is not used to manage lifetimes & stuff AT ALL.
 
 import (
+	"errors"
 	"fmt"
 	"html/template"
 	"net/http"
 	"strings"
 
 	"github.com/bctnry/aegis/pkg/aegis"
+	"github.com/bctnry/aegis/pkg/aegis/confirm_code"
 	"github.com/bctnry/aegis/pkg/aegis/db"
 	"github.com/bctnry/aegis/pkg/aegis/mail"
 	"github.com/bctnry/aegis/pkg/aegis/model"
 	"github.com/bctnry/aegis/pkg/aegis/receipt"
 	"github.com/bctnry/aegis/pkg/aegis/session"
 	"github.com/bctnry/aegis/pkg/aegis/ssh"
-	"github.com/bctnry/aegis/pkg/aegis/confirm_code"
 	"github.com/bctnry/aegis/templates"
 )
 
@@ -169,6 +170,8 @@ func ParseRepositoryFullName(str string) (string, string) {
 	return namespaceName, repoName
 }
 
+var ErrNotFound = errors.New("Requested object not found")
+
 // we need the namespace acl to supplement the repository acl in terms
 // of business logic.
 func (ctx *RouterContext) ResolveRepositoryFullName(str string) (string, string, *model.Namespace, *model.Repository, error) {

routes/controller/branch.go

@@ -1,9 +1,11 @@
 package controller
 
 import (
+	"bytes"
 	"fmt"
 	"mime"
 	"net/http"
+	"os/exec"
 	"path"
 	"strings"
 
@@ -139,11 +141,13 @@ func bindBranchController(ctx *RouterContext) {
 			return
 		}
 
+		isTargetBlob := target.Type() == gitlib.BLOB
+
 		// if it's a query for snapshot of a tree we directly output
 		// the tree object as a .zip file
 		isSnapshotRequest :=  r.URL.Query().Has("snapshot")
 		if isSnapshotRequest {
-			if target.Type() == gitlib.BLOB {
+			if isTargetBlob {
 				mime := mime.TypeByExtension(path.Ext(treePath))
 				if len(mime) <= 0 { mime = "application/octet-stream" }
 				w.Header().Add("Content-Type", mime)
@@ -179,46 +183,66 @@ func bindBranchController(ctx *RouterContext) {
 		permaLink := fmt.Sprintf("/repo/%s/commit/%s/%s", rfn, cobj.Id, treePath)
 
 		isBlameRequest := r.URL.Query().Has("blame")
-		if isBlameRequest {
-			if target.Type() == gitlib.BLOB {
-				mime := mime.TypeByExtension(path.Ext(treePath))
-				if len(mime) <= 0 { mime = "application/octet-stream" }
-				if !strings.HasPrefix(mime, "image/") {
-					dirPath := path.Dir(treePath) + "/"
-					dirObj, err := rr.ResolveTreePath(gobj.(*gitlib.TreeObject), dirPath)
-					if err != nil {
-						ctx.ReportInternalError(err.Error(), w, r)
-						return
-					}
-					blame, err := rr.Blame(cobj, treePath)
-					if err != nil {
-						ctx.ReportInternalError(fmt.Sprintf("Failed to run git-blame: %s.", err), w, r)
-						return
-					}
-					LogTemplateError(ctx.LoadTemplate("git-blame").Execute(w, &templates.GitBlameTemplateModel{
-						Repository: repo,
-						RepoHeaderInfo: *repoHeaderInfo,
-						TreeFileList: &templates.TreeFileListTemplateModel{
-							ShouldHaveParentLink: len(treePath) > 0,
-							RepoPath: fmt.Sprintf("/repo/%s", rfn),
-							RootPath: fmt.Sprintf("/repo/%s/%s/%s", rfn, "branch", branchName),
-							TreePath: dirPath,
-							FileList: dirObj.(*gitlib.TreeObject).ObjectList,
-						},
-						TreePath: treePathModelValue,
-						PermaLink: permaLink,
-						Blame: blame,
-						CommitInfo: commitInfo,
-						TagInfo: nil,
-						LoginInfo: loginInfo,
-						Config: ctx.Config,
-					}))
+		if isBlameRequest && isTargetBlob {
+			mime := mime.TypeByExtension(path.Ext(treePath))
+			if len(mime) <= 0 { mime = "application/octet-stream" }
+			if !strings.HasPrefix(mime, "image/") {
+				dirPath := path.Dir(treePath) + "/"
+				dirObj, err := rr.ResolveTreePath(gobj.(*gitlib.TreeObject), dirPath)
+				if err != nil {
+					ctx.ReportInternalError(err.Error(), w, r)
+					return
+				}
+				blame, err := rr.Blame(cobj, treePath)
+				if err != nil {
+					ctx.ReportInternalError(fmt.Sprintf("Failed to run git-blame: %s.", err), w, r)
 					return
 				}
+				LogTemplateError(ctx.LoadTemplate("git-blame").Execute(w, &templates.GitBlameTemplateModel{
+					Repository: repo,
+					RepoHeaderInfo: *repoHeaderInfo,
+					TreeFileList: &templates.TreeFileListTemplateModel{
+						ShouldHaveParentLink: len(treePath) > 0,
+						RepoPath: fmt.Sprintf("/repo/%s", rfn),
+						RootPath: fmt.Sprintf("/repo/%s/%s/%s", rfn, "branch", branchName),
+						TreePath: dirPath,
+						FileList: dirObj.(*gitlib.TreeObject).ObjectList,
+					},
+					TreePath: treePathModelValue,
+					PermaLink: permaLink,
+					Blame: blame,
+					CommitInfo: commitInfo,
+					TagInfo: nil,
+					LoginInfo: loginInfo,
+					Config: ctx.Config,
+				}))
+				return
 			}
 		}
 
-		
+		isEditRequest := r.URL.Query().Has("edit")
+		if isEditRequest && isTargetBlob {
+			mime := mime.TypeByExtension(path.Ext(treePath))
+			if len(mime) <= 0 { mime = "application/octet-stream" }
+			if !strings.HasPrefix(mime, "image/") {
+				LogTemplateError(ctx.LoadTemplate("edit-file").Execute(w, &templates.EditFileTemplateModel{
+					Config: ctx.Config,
+					Repository: repo,
+					RepoHeaderInfo: *repoHeaderInfo,
+					PermaLink: permaLink,
+					FullTreePath: treePath,
+					FileContent: string(target.(*gitlib.BlobObject).Data),
+					CommitInfo: commitInfo,
+					TagInfo: nil,
+					LoginInfo: loginInfo,
+				}))
+			} else {
+				// TODO: upload.
+			}
+			return
+		}
+			
+			
 		switch target.Type() {
 		case gitlib.TREE:
 			if len(treePath) > 0 && !strings.HasSuffix(treePath, "/") {
@@ -319,8 +343,97 @@ func bindBranchController(ctx *RouterContext) {
 		default:
 			ctx.ReportInternalError("", w, r)
 		}
-
 	}))
+
+	http.HandleFunc("POST /repo/{repoName}/branch/{branchName}/{treePath...}", UseMiddleware(
+		[]Middleware{
+			Logged, LoginRequired, GlobalVisibility,
+			ValidRepositoryNameRequired("repoName"),
+			ErrorGuard,
+		}, ctx,
+		func(rc *RouterContext, w http.ResponseWriter, r *http.Request) {
+			rfn := r.PathValue("repoName")
+			_, _, _, repo, err := rc.ResolveRepositoryFullName(rfn)
+			if err == routes.ErrNotFound {
+				rc.ReportNotFound(rfn, "Repository", "Depot", w, r)
+				return
+			}
+			if err != nil {
+				rc.ReportInternalError(err.Error(), w, r)
+				return
+			}
+			if repo.Type != model.REPO_TYPE_GIT {
+				rc.ReportNormalError("The repository you have requested isn't a Git repository.", w, r)
+				return
+			}
+			if rc.Config.PlainMode {
+				FoundAt(w, fmt.Sprintf("/repo/%s/branch/%s/%s", rfn, r.PathValue("branchName"), r.PathValue("treePath")))
+				return
+			}
+			err = r.ParseForm()
+			if err != nil {
+				rc.ReportNormalError("Invalid request", w, r)
+				return
+			}
+			if repo.Owner != rc.LoginInfo.UserName {
+				rc.ReportRedirect(
+					fmt.Sprintf("/repo/%s/branch/%s/%s", rfn, r.PathValue("branchName"), r.PathValue("treePath")),
+					5,
+					"Not Enough Privilege",
+					"Your account doesn't have enough privilege to perform this action.",
+					w, r,
+				)
+			}
+			commitMessage := r.Form.Get("commit-message")
+			content := r.Form.Get("content")
+			branchName := r.PathValue("branchName")
+			treePath := r.PathValue("treePath")
+			payload := fmt.Sprintf(`commit refs/heads/%s
+mark :1
+author %s <%s> now
+committer %s <%s> now
+data %d
+%s
+from refs/heads/%s^0
+M 100644 inline %s
+data %d
+%s
+get-mark :1`,
+				branchName,
+				rc.LoginInfo.UserFullName, rc.LoginInfo.UserEmail,
+				rc.LoginInfo.UserFullName, rc.LoginInfo.UserEmail,
+				len(commitMessage),
+				commitMessage,
+				branchName,
+				treePath,
+				len(content),
+				content,
+			)
+			cmd := exec.Command("git", "fast-import", "--date-format=now", "--quiet")
+			stdoutBuf := new(bytes.Buffer)
+			stderrBuf := new(bytes.Buffer)
+			cmd.Dir = repo.LocalPath
+			cmd.Stdout = stdoutBuf
+			cmd.Stderr = stderrBuf
+			cmd.Stdin = bytes.NewReader([]byte(payload))
+			err = cmd.Run()
+			if err != nil {
+				rc.ReportInternalError(fmt.Sprintf("Failed to fast-import commit: %s; %s", err.Error(), stderrBuf.String()), w, r)
+				return
+			}
+			commitId := strings.TrimSpace(stdoutBuf.String())
+			cmd2 := exec.Command("git", "update-ref", fmt.Sprintf("refs/heads/%s", branchName), commitId)
+			cmd2.Dir = repo.LocalPath
+			stderrBuf.Reset()
+			cmd2.Stderr = stderrBuf
+			err = cmd2.Run()
+			if err != nil {
+				rc.ReportInternalError(fmt.Sprintf("Failed to update ref: %s; %s", err.Error(), stderrBuf.String()), w, r)
+				return
+			}
+			rc.ReportRedirect(fmt.Sprintf("/repo/%s/branch/%s/%s", rfn, branchName, treePath), 5, "Updated", "Your edit has been saved to the repository.", w, r)
+		},
+	))
 }
 
 

routes/controller/namespace-setting.go

@@ -536,7 +536,7 @@ func bindNamespaceSettingController(ctx *RouterContext) {
 			PushToRepository: len(r.Form.Get("pushToRepo")) > 0,
 			ArchiveRepository: len(r.Form.Get("archiveRepo")) > 0,
 			DeleteRepository: len(r.Form.Get("deleteRepo")) > 0,
-			EditHooks: len(r.Form.Get("editHooks")) > 0,
+			EditWebHooks: len(r.Form.Get("editWebHooks")) > 0,
 		}
 		err = ctx.DatabaseInterface.SetNamespaceACL(namespaceName, targetUsername, t)
 		if err != nil {