func createPullRequestMessage(base, head, fullBase, fullHead string) (string, error) {
var (
defaultMsg string
commitLogs string
err error
)
commits, _ := git.RefList(base, head)
if len(commits) == 1 {
defaultMsg, err = git.Show(commits[0])
if err != nil {
return "", err
}
} else if len(commits) > 1 {
commitLogs, err = git.Log(base, head)
if err != nil {
return "", err
}
}
workdir, err := git.WorkdirName()
if err != nil {
return "", err
}
template, err := github.ReadTemplate(github.PullRequestTemplate, workdir)
if err != nil {
return "", err
} else if template != "" {
if defaultMsg == "" {
defaultMsg = "\n\n" + template
} else {
parts := strings.SplitN(defaultMsg, "\n\n", 2)
defaultMsg = parts[0] + "\n\n" + template
if len(parts) > 1 && parts[1] != "" {
defaultMsg = defaultMsg + "\n\n" + parts[1]
}
}
}
cs := git.CommentChar()
return renderPullRequestTpl(defaultMsg, cs, fullBase, fullHead, commitLogs)
}
func pullRequestChangesMessage(base, head, fullBase, fullHead string) (string, error) {
var (
defaultMsg string
commitLogs string
err error
)
commits, _ := git.RefList(base, head)
if len(commits) == 1 {
defaultMsg, err = git.Show(commits[0])
if err != nil {
return "", err
}
} else if len(commits) > 1 {
commitLogs, err = git.Log(base, head)
if err != nil {
return "", err
}
}
cs := git.CommentChar()
return renderPullRequestTpl(defaultMsg, cs, fullBase, fullHead, commitLogs)
}
func NewEditor(filePrefix, topic, message string) (editor *Editor, err error) {
messageFile, err := getMessageFile(filePrefix)
if err != nil {
return
}
program, err := git.Editor()
if err != nil {
return
}
cs := git.CommentChar()
editor = &Editor{
Program: program,
Topic: topic,
File: messageFile,
Message: message,
CS: cs,
openEditor: openTextEditor,
}
return
}
func editRelease(cmd *Command, args *Args) {
tagName := cmd.Arg(0)
if tagName == "" {
utils.Check(fmt.Errorf("Missing argument TAG"))
return
}
localRepo, err := github.LocalRepo()
utils.Check(err)
project, err := localRepo.CurrentProject()
utils.Check(err)
gh := github.NewClient(project.Host)
release, err := gh.FetchRelease(project, tagName)
utils.Check(err)
params := map[string]interface{}{}
commitish := release.TargetCommitish
if cmd.FlagPassed("commitish") {
params["target_commitish"] = flagReleaseCommitish
commitish = flagReleaseCommitish
}
if cmd.FlagPassed("draft") {
params["draft"] = flagReleaseDraft
}
if cmd.FlagPassed("prerelease") {
params["prerelease"] = flagReleasePrerelease
}
var title string
var body string
var editor *github.Editor
if cmd.FlagPassed("message") {
title, body = readMsg(flagReleaseMessage)
} else if cmd.FlagPassed("file") {
title, body, editor, err = readMsgFromFile(flagReleaseFile, flagReleaseEdit, "RELEASE", "release")
utils.Check(err)
if title == "" {
utils.Check(fmt.Errorf("Aborting editing due to empty release title"))
}
} else {
cs := git.CommentChar()
message, err := renderReleaseTpl("Editing", cs, tagName, project.String(), commitish)
utils.Check(err)
message = fmt.Sprintf("%s\n\n%s\n%s", release.Name, release.Body, message)
editor, err := github.NewEditor("RELEASE", "release", message)
utils.Check(err)
title, body, err = editor.EditTitleAndBody()
utils.Check(err)
if title == "" {
utils.Check(fmt.Errorf("Aborting editing due to empty release title"))
}
}
if title != "" {
params["name"] = title
}
if body != "" {
params["body"] = body
}
if len(params) > 0 {
if args.Noop {
ui.Printf("Would edit release `%s'\n", tagName)
} else {
release, err = gh.EditRelease(release, params)
utils.Check(err)
}
if editor != nil {
editor.DeleteFile()
}
}
uploadAssets(gh, release, flagReleaseAssets, args)
args.NoForward()
}
func createRelease(cmd *Command, args *Args) {
tagName := cmd.Arg(0)
if tagName == "" {
utils.Check(fmt.Errorf("Missing argument TAG"))
return
}
localRepo, err := github.LocalRepo()
utils.Check(err)
project, err := localRepo.CurrentProject()
utils.Check(err)
gh := github.NewClient(project.Host)
var title string
var body string
var editor *github.Editor
if cmd.FlagPassed("message") {
title, body = readMsg(flagReleaseMessage)
} else if cmd.FlagPassed("file") {
title, body, editor, err = readMsgFromFile(flagReleaseFile, flagReleaseEdit, "RELEASE", "release")
utils.Check(err)
} else {
cs := git.CommentChar()
message, err := renderReleaseTpl("Creating", cs, tagName, project.String(), flagReleaseCommitish)
utils.Check(err)
editor, err := github.NewEditor("RELEASE", "release", message)
utils.Check(err)
title, body, err = editor.EditTitleAndBody()
utils.Check(err)
}
if title == "" {
utils.Check(fmt.Errorf("Aborting release due to empty release title"))
}
params := &github.Release{
TagName: tagName,
TargetCommitish: flagReleaseCommitish,
Name: title,
Body: body,
Draft: flagReleaseDraft,
Prerelease: flagReleasePrerelease,
}
var release *github.Release
args.NoForward()
if args.Noop {
ui.Printf("Would create release `%s' for %s with tag name `%s'\n", title, project, tagName)
} else {
release, err = gh.CreateRelease(project, params)
utils.Check(err)
printBrowseOrCopy(args, release.HtmlUrl, flagReleaseBrowse, flagReleaseCopy)
}
if editor != nil {
editor.DeleteFile()
}
uploadAssets(gh, release, flagReleaseAssets, args)
}
func createIssue(cmd *Command, args *Args) {
localRepo, err := github.LocalRepo()
utils.Check(err)
project, err := localRepo.MainProject()
utils.Check(err)
gh := github.NewClient(project.Host)
var title string
var body string
var editor *github.Editor
if cmd.FlagPassed("message") {
title, body = readMsg(flagIssueMessage)
} else if cmd.FlagPassed("file") {
title, body, err = readMsgFromFile(flagIssueFile)
utils.Check(err)
} else {
cs := git.CommentChar()
message := strings.Replace(fmt.Sprintf(`
# Creating an issue for %s
#
# Write a message for this issue. The first block of
# text is the title and the rest is the description.
`, project), "#", cs, -1)
editor, err := github.NewEditor("ISSUE", "issue", message)
utils.Check(err)
title, body, err = editor.EditTitleAndBody()
utils.Check(err)
}
if title == "" {
utils.Check(fmt.Errorf("Aborting creation due to empty issue title"))
}
params := map[string]interface{}{
"title": title,
"body": body,
"labels": flagIssueLabels,
"assignees": flagIssueAssignees,
}
if flagIssueMilestone > 0 {
params["milestone"] = flagIssueMilestone
}
if args.Noop {
ui.Printf("Would create issue `%s' for %s\n", params["title"], project)
os.Exit(0)
} else {
issue, err := gh.CreateIssue(project, params)
utils.Check(err)
if editor != nil {
editor.DeleteFile()
}
if flagIssueBrowse {
launcher, err := utils.BrowserLauncher()
utils.Check(err)
args.Replace(launcher[0], "", launcher[1:]...)
args.AppendParams(issue.HtmlUrl)
} else {
ui.Println(issue.HtmlUrl)
os.Exit(0)
}
}
}
func createRelease(cmd *Command, args *Args) {
if args.IsParamsEmpty() {
utils.Check(fmt.Errorf("Missed argument TAG"))
return
}
tag := args.LastParam()
runInLocalRepo(func(localRepo *github.GitHubRepo, project *github.Project, client *github.Client) {
release, err := client.Release(project, tag)
utils.Check(err)
if release == nil {
commitish := flagReleaseCommitish
if commitish == "" {
currentBranch, err := localRepo.CurrentBranch()
utils.Check(err)
commitish = currentBranch.ShortName()
}
title, body, err := getTitleAndBodyFromFlags(flagReleaseMessage, flagReleaseFile)
utils.Check(err)
var editor *github.Editor
if title == "" {
cs := git.CommentChar()
message, err := renderReleaseTpl(cs, tag, project.Name, commitish)
utils.Check(err)
editor, err = github.NewEditor("RELEASE", "release", message)
utils.Check(err)
title, body, err = editor.EditTitleAndBody()
utils.Check(err)
}
params := octokit.ReleaseParams{
TagName: tag,
TargetCommitish: commitish,
Name: title,
Body: body,
Draft: flagReleaseDraft,
Prerelease: flagReleasePrerelease,
}
release, err = client.CreateRelease(project, params)
utils.Check(err)
if editor != nil {
defer editor.DeleteFile()
}
}
if len(flagReleaseAssets) > 0 {
paths := make([]string, 0)
for _, asset := range flagReleaseAssets {
finder := assetFinder{}
p, err := finder.Find(asset)
utils.Check(err)
paths = append(paths, p...)
}
uploader := assetUploader{
Client: client,
Release: release,
}
err = uploader.UploadAll(paths)
if err != nil {
ui.Println("")
utils.Check(err)
}
}
ui.Printf("\n%s\n", release.HTMLURL)
})
}
func createIssue(cmd *Command, args *Args) {
localRepo, err := github.LocalRepo()
utils.Check(err)
project, err := localRepo.MainProject()
utils.Check(err)
gh := github.NewClient(project.Host)
var title string
var body string
var editor *github.Editor
if cmd.FlagPassed("message") {
title, body = readMsg(flagIssueMessage)
} else if cmd.FlagPassed("file") {
title, body, editor, err = readMsgFromFile(flagIssueFile, flagIssueEdit, "ISSUE", "issue")
utils.Check(err)
} else {
cs := git.CommentChar()
message := strings.Replace(fmt.Sprintf(`
# Creating an issue for %s
#
# Write a message for this issue. The first block of
# text is the title and the rest is the description.
`, project), "#", cs, -1)
workdir, err := git.WorkdirName()
utils.Check(err)
template, err := github.ReadTemplate(github.IssueTemplate, workdir)
utils.Check(err)
if template != "" {
message = template + "\n" + message
}
editor, err := github.NewEditor("ISSUE", "issue", message)
utils.Check(err)
title, body, err = editor.EditTitleAndBody()
utils.Check(err)
}
if editor != nil {
defer editor.DeleteFile()
}
if title == "" {
utils.Check(fmt.Errorf("Aborting creation due to empty issue title"))
}
params := map[string]interface{}{
"title": title,
"body": body,
}
if len(flagIssueLabels) > 0 {
params["labels"] = flagIssueLabels
}
if len(flagIssueAssignees) > 0 {
params["assignees"] = flagIssueAssignees
}
if flagIssueMilestone > 0 {
params["milestone"] = flagIssueMilestone
}
args.NoForward()
if args.Noop {
ui.Printf("Would create issue `%s' for %s\n", params["title"], project)
} else {
issue, err := gh.CreateIssue(project, params)
utils.Check(err)
printBrowseOrCopy(args, issue.HtmlUrl, flagIssueBrowse, flagIssueCopy)
}
}