tsukinoko-kun/git-roast
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: tsukinoko-kun:request
Branches Tags
tsukinoko-kun:main
tsukinoko-kun:request
..
compare: tsukinoko-kun:main
Branches Tags
tsukinoko-kun:request
tsukinoko-kun:main

No commits in common. "request" and "main" have entirely different histories.
request ... main

4 changed files with 6 additions and 191 deletions
Show Stats Expand all files Collapse all files

19
internal/roast/info.go
View File

@ -1,10 +1,5 @@
package roast
import (
"os/exec"
"strings"
)
func (r *Roast) CurrentBranchName() (string, bool) {
head, err := r.repo.Head()
if err != nil {
@ -13,17 +8,3 @@ func (r *Roast) CurrentBranchName() (string, bool) {
return head.Name().Short(), true
}
var gitusername string
func GitUserName() string {
if len(gitusername) != 0 {
return gitusername
}
if out, err := exec.Command("git", "config", "user.name").Output(); err != nil {
return ""
} else {
gitusername = strings.TrimSpace(string(out))
return gitusername
}
}

67
internal/roast/request.go
View File

@ -4,12 +4,6 @@ import (
"errors"
"fmt"
"git-roast/internal/log"
"git-roast/internal/util"
"net/url"
"os"
"os/exec"
"path/filepath"
"time"
)
func (r *Roast) Request(from string, into string) error {
@ -19,72 +13,19 @@ func (r *Roast) Request(from string, into string) error {
if err != nil {
return errors.Join(fmt.Errorf("failed to get source branch %s", from), err)
}
log.Debugf("branch %s found\n", sourceBranch.Name)
targetBranch, err := r.repo.Branch(into)
if err != nil {
return errors.Join(fmt.Errorf("failed to get target branch %s", from), err)
}
log.Debugf("branch %s found\n", targetBranch.Name)
id := url.PathEscape(fmt.Sprintf(
"%016x_from_%s_into_%s",
time.Now().Unix(),
id := fmt.Sprintf(
"from_%s_into_%s",
sourceBranch.Name,
targetBranch.Name,
))
)
initialMessage, err := util.Textedit(fmt.Sprintf(
"%s is requesting merge into `%s` from `%s`\n",
GitUserName(),
into,
from,
))
if err != nil {
return err
}
fmt.Println(id)
p := filepath.Join(r.dir, id)
if err := os.MkdirAll(p, 0700); err != nil {
return errors.Join(errors.New("failed to create directory for request"), err)
}
successful := false
defer func() {
if !successful {
clean := exec.Command("git", "clean", "-xfd")
clean.Path = r.dir
_ = clean.Run()
log.Printf("action not successful, rollback...\n")
reset := exec.Command("git", "reset", "--hard")
reset.Path = r.dir
_ = reset.Run()
}
}()
f, err := os.Create(filepath.Join(p, fmt.Sprintf(
"%016x_%s.md",
time.Now().Unix(),
GitUserName(),
)))
if err != nil {
return errors.Join(errors.New("failed to create file for request"), err)
}
if _, err := f.Write([]byte(initialMessage)); err != nil {
return errors.Join(errors.New("failed to write to file for request"), err)
}
if err := r.AddAll(); err != nil {
return errors.Join(errors.New("failed to add changes before commit"), err)
}
if err := r.Commit(id); err != nil {
return errors.Join(errors.New("failed to commit changes before push request"), err)
}
if err := r.Push(); err != nil {
return errors.Join(errors.New("failed to push request"), err)
}
successful = true
return nil
}

51
internal/roast/roast.go
View File

@ -169,55 +169,8 @@ func Open() (*Roast, error) {
return nil, errors.Join(fmt.Errorf("failed to open roast repo %s", p), err)
}
r := &Roast{
return &Roast{
repo: roastRepo,
dir: p,
}
return r, r.Pull()
}
func (r *Roast) Pull() error {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
defer cancel()
log.Debugf("git pull --force\n")
pullCmd := exec.CommandContext(ctx, "git", "pull", "--force")
pullCmd.Dir = r.dir
pullCmd.Stdin = os.Stdin
pullCmd.Stdout = os.Stdout
pullCmd.Stderr = os.Stderr
return pullCmd.Run()
}
func (r *Roast) AddAll() error {
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
log.Debugf("git add .\n")
addCmd := exec.CommandContext(ctx, "git", "add", ".")
addCmd.Dir = r.dir
return addCmd.Run()
}
func (r *Roast) Commit(m string) error {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
defer cancel()
log.Debugf("git commit\n")
commitCmd := exec.CommandContext(ctx, "git", "commit", "-m", m)
commitCmd.Dir = r.dir
commitCmd.Stdin = os.Stdin
commitCmd.Stdout = os.Stdout
commitCmd.Stderr = os.Stderr
return commitCmd.Run()
}
func (r *Roast) Push() error {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
defer cancel()
log.Debugf("git push --atomic\n")
pushCmd := exec.CommandContext(ctx, "git", "push", "--atomic")
pushCmd.Dir = r.dir
pushCmd.Stdin = os.Stdin
pushCmd.Stdout = os.Stdout
pushCmd.Stderr = os.Stderr
return pushCmd.Run()
}, nil
}

60
internal/util/textedit.go
View File

@ -1,60 +0,0 @@
package util
import (
"context"
"errors"
"git-roast/internal/log"
"io"
"os"
"os/exec"
"strings"
"time"
)
func Textedit(text string) (string, error) {
f, err := os.CreateTemp("", "git-roast-*.md")
if err != nil {
return text, errors.Join(errors.New("failed to create initial message in request"), err)
}
fp := f.Name()
defer os.Remove(fp)
_, _ = f.Write([]byte(text))
f.Close()
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Minute)
defer cancel()
ed := editor()
log.Debugf("editing message using %s\n", ed)
edCmd := exec.CommandContext(ctx, ed, fp)
edCmd.Stderr = os.Stderr
edCmd.Stdout = os.Stdout
edCmd.Stdin = os.Stdin
if err := edCmd.Run(); err != nil {
return text, errors.Join(errors.New("failed to run text editor"), err)
}
f, err = os.OpenFile(fp, os.O_RDONLY|os.O_SYNC, 0)
if err != nil {
return text, errors.Join(errors.New("failed to open temp file"), err)
}
defer f.Close()
newContent, err := io.ReadAll(f)
if err != nil {
return text, errors.Join(errors.New("failed to read from temp file"), err)
}
return string(newContent), nil
}
func editor() string {
if gitCoreEditor, err := exec.Command("git", "config", "--global", "core.editor").Output(); err == nil {
return strings.TrimSpace(string(gitCoreEditor))
}
if gitEditor, ok := os.LookupEnv("GIT_EDITOR"); ok {
return gitEditor
}
if editor, ok := os.LookupEnv("EDITOR"); ok {
return editor
}
return "vim"
}