New actionable dialogue

go/interactive/add_prs_to_issue.go

@@ -24,27 +24,27 @@ import (
 
 type addPRsToIssue string
 
-func addPRsToIssueMenuItem(ctx *releaser.Context) menuItem {
-	return menuItem{
+func addPRsToIssueMenuItem(ctx *releaser.Context) *menuItem {
+	return &menuItem{
 		ctx:    ctx,
 		name:   "Backport Pull Requests: Add to Release Issue",
 		act:    addPRsToIssueAct,
 		update: addPRsToIssueUpdate,
 	}
 }
 
-func addPRsToIssueUpdate(mi menuItem, msg tea.Msg) (menuItem, tea.Cmd) {
+func addPRsToIssueUpdate(mi *menuItem, msg tea.Msg) (*menuItem, tea.Cmd) {
 	releaseIssueLink, ok := msg.(addPRsToIssue)
 	if !ok {
 		return mi, nil
 	}
 
-	mi.state = string(releaseIssueLink)
+	mi.info = string(releaseIssueLink)
 	return mi, nil
 }
 
-func addPRsToIssueAct(mi menuItem) (menuItem, tea.Cmd) {
-	mi.state = "running..."
+func addPRsToIssueAct(mi *menuItem) (*menuItem, tea.Cmd) {
+	mi.info = "running..."
 	pl, add := issue.AddBackportPRs(mi.ctx)
 	return mi, tea.Batch(func() tea.Msg {
 		return addPRsToIssue(add())

go/interactive/add_release_blocker_issues_to_issue.go

@@ -24,27 +24,27 @@ import (
 
 type addReleaseBlockerIssues string
 
-func addReleaseBlockerIssuesMenuItem(ctx *releaser.Context) menuItem {
-	return menuItem{
+func addReleaseBlockerIssuesMenuItem(ctx *releaser.Context) *menuItem {
+	return &menuItem{
 		ctx:    ctx,
 		name:   "Release Blocker Issues: Add to Release Issue",
 		act:    addReleaseBlockerIssuesAct,
 		update: addReleaseBlockerIssuesUpdate,
 	}
 }
 
-func addReleaseBlockerIssuesUpdate(mi menuItem, msg tea.Msg) (menuItem, tea.Cmd) {
+func addReleaseBlockerIssuesUpdate(mi *menuItem, msg tea.Msg) (*menuItem, tea.Cmd) {
 	releaseIssueLink, ok := msg.(addReleaseBlockerIssues)
 	if !ok {
 		return mi, nil
 	}
 
-	mi.state = string(releaseIssueLink)
+	mi.info = string(releaseIssueLink)
 	return mi, nil
 }
 
-func addReleaseBlockerIssuesAct(mi menuItem) (menuItem, tea.Cmd) {
-	mi.state = "running..."
+func addReleaseBlockerIssuesAct(mi *menuItem) (*menuItem, tea.Cmd) {
+	mi.info = "running..."
 	pl, add := issue.AddReleaseBlockerIssues(mi.ctx)
 	return mi, tea.Batch(func() tea.Msg {
 		return addReleaseBlockerIssues(add())

go/interactive/check_prs.go

@@ -26,29 +26,29 @@ import (
 
 type openPRs []string
 
-func checkPRsMenuItem(ctx *releaser.Context) menuItem {
-	return menuItem{
+func checkPRsMenuItem(ctx *releaser.Context) *menuItem {
+	return &menuItem{
 		ctx:    ctx,
 		name:   "Backport Pull Requests: Check",
 		act:    checkPRsAct,
 		update: checkPRsUpdate,
 	}
 }
 
-func checkPRsAct(mi menuItem) (menuItem, tea.Cmd) {
-	mi.state = "Checking pull requests..."
+func checkPRsAct(mi *menuItem) (*menuItem, tea.Cmd) {
+	mi.info = "Checking pull requests..."
 	return mi, func() tea.Msg {
 		prs := prerequisite.FormatPRs(prerequisite.CheckPRs(mi.ctx))
 		return openPRs(prs)
 	}
 }
 
-func checkPRsUpdate(mi menuItem, msg tea.Msg) (menuItem, tea.Cmd) {
+func checkPRsUpdate(mi *menuItem, msg tea.Msg) (*menuItem, tea.Cmd) {
 	prs, ok := msg.(openPRs)
 	if !ok {
 		return mi, nil
 	}
-	mi.state = fmt.Sprintf("Done, %d PRs need to be merged.", len(prs))
+	mi.info = fmt.Sprintf("Done, %d PRs need to be merged.", len(prs))
 	if len(prs) == 0 {
 		return mi, nil
 	}

go/interactive/check_release_blockers_issue.go

@@ -26,29 +26,29 @@ import (
 
 type releaseBlockerIssues []string
 
-func releaseBlockerIssuesMenuItem(ctx *releaser.Context) menuItem {
-	return menuItem{
+func releaseBlockerIssuesMenuItem(ctx *releaser.Context) *menuItem {
+	return &menuItem{
 		ctx:    ctx,
 		name:   "Release Blocker Issues: Check",
 		act:    releaseBlockerIssuesAct,
 		update: releaseBlockerIssuesUpdate,
 	}
 }
 
-func releaseBlockerIssuesAct(mi menuItem) (menuItem, tea.Cmd) {
-	mi.state = "Checking Issues..."
+func releaseBlockerIssuesAct(mi *menuItem) (*menuItem, tea.Cmd) {
+	mi.info = "Checking Issues..."
 	return mi, func() tea.Msg {
 		issues := prerequisite.FormatIssues(prerequisite.CheckReleaseBlockerIssues(mi.ctx))
 		return releaseBlockerIssues(issues)
 	}
 }
 
-func releaseBlockerIssuesUpdate(mi menuItem, msg tea.Msg) (menuItem, tea.Cmd) {
+func releaseBlockerIssuesUpdate(mi *menuItem, msg tea.Msg) (*menuItem, tea.Cmd) {
 	is, ok := msg.(releaseBlockerIssues)
 	if !ok {
 		return mi, nil
 	}
-	mi.state = fmt.Sprintf("Done, %d Issues need to be closed.", len(is))
+	mi.info = fmt.Sprintf("Done, %d Issues need to be closed.", len(is))
 	if len(is) == 0 {
 		return mi, nil
 	}

go/interactive/check_summary.go

@@ -18,37 +18,37 @@ package interactive
 
 import (
 	tea "github.com/charmbracelet/bubbletea"
+	"vitess.io/vitess-releaser/go/interactive/state"
 	"vitess.io/vitess-releaser/go/releaser"
 	"vitess.io/vitess-releaser/go/releaser/prerequisite"
 )
 
 type checkSummary []string
 
-func checkSummaryMenuItem(ctx *releaser.Context) menuItem {
-	return menuItem{
+func checkSummaryMenuItem(ctx *releaser.Context) *menuItem {
+	return &menuItem{
 		ctx:    ctx,
 		name:   "Check release note summary",
+		status: state.ToDo, // TODO: read initial status from Release Issue on GitHub
 		act:    checkSummaryAct,
 		update: checkSummaryUpdate,
 	}
 }
 
-func checkSummaryUpdate(mi menuItem, msg tea.Msg) (menuItem, tea.Cmd) {
+func checkSummaryUpdate(mi *menuItem, msg tea.Msg) (*menuItem, tea.Cmd) {
 	l, ok := msg.(checkSummary)
 	if !ok {
 		return mi, nil
 	}
 
-	// TODO: i think the goal here is to mark this as done only when the action is marked as done in the release issue
-	// mi.state = fmt.Sprintf("Done.")
-
-	return mi, pushDialog(infoDialog{
+	return mi, pushDialog(doneDialog{
 		title:   "Check release note summary",
 		message: l,
+		status:  &mi.status,
 	})
 }
 
-func checkSummaryAct(mi menuItem) (menuItem, tea.Cmd) {
+func checkSummaryAct(mi *menuItem) (*menuItem, tea.Cmd) {
 	return mi, func() tea.Msg {
 		return checkSummary(prerequisite.CheckSummary(mi.ctx))
 	}

go/interactive/code_freeze.go

@@ -18,34 +18,37 @@ package interactive
 
 import (
 	tea "github.com/charmbracelet/bubbletea"
+	"vitess.io/vitess-releaser/go/interactive/state"
 	"vitess.io/vitess-releaser/go/releaser"
 
 	"vitess.io/vitess-releaser/go/releaser/pre_release"
 )
 
-func codeFreezeMenuItem(ctx *releaser.Context) menuItem {
-	return menuItem{
+func codeFreezeMenuItem(ctx *releaser.Context) *menuItem {
+	return &menuItem{
 		ctx:    ctx,
 		name:   "Code freeze",
 		act:    codeFreezeAct,
 		init:   nil,
 		update: codeFreezeUpdate,
+		status: state.ToDo, // TODO: read the initial state from the Release Issue on GitHub
 	}
 }
 
 type codeFreezeUrl string
 
-func codeFreezeUpdate(mi menuItem, msg tea.Msg) (menuItem, tea.Cmd) {
+func codeFreezeUpdate(mi *menuItem, msg tea.Msg) (*menuItem, tea.Cmd) {
 	url, ok := msg.(codeFreezeUrl)
 	if !ok {
 		return mi, nil
 	}
-	mi.state = string(url)
+	mi.info = string(url)
+	mi.status = state.Done
 	return mi, nil
 }
 
-func codeFreezeAct(mi menuItem) (menuItem, tea.Cmd) {
-	mi.state = "running..."
+func codeFreezeAct(mi *menuItem) (*menuItem, tea.Cmd) {
+	mi.info = "running..."
 	pl, freeze := pre_release.CodeFreeze(mi.ctx)
 	return mi, tea.Batch(func() tea.Msg {
 		return codeFreezeUrl(freeze())

go/interactive/create_github_milestones.go

@@ -18,33 +18,36 @@ package interactive
 
 import (
 	tea "github.com/charmbracelet/bubbletea"
+	"vitess.io/vitess-releaser/go/interactive/state"
 	"vitess.io/vitess-releaser/go/releaser"
 	"vitess.io/vitess-releaser/go/releaser/pre_release"
 )
 
 type createMilestone string
 
-func createMilestoneMenuItem(ctx *releaser.Context) menuItem {
-	return menuItem{
+func createMilestoneMenuItem(ctx *releaser.Context) *menuItem {
+	return &menuItem{
 		ctx:    ctx,
 		name:   "Create a new GitHub Milestone",
 		act:    createMilestoneAct,
 		update: createMilestoneUpdate,
+		status: state.ToDo,
 	}
 }
 
-func createMilestoneUpdate(mi menuItem, msg tea.Msg) (menuItem, tea.Cmd) {
+func createMilestoneUpdate(mi *menuItem, msg tea.Msg) (*menuItem, tea.Cmd) {
 	milestoneLink, ok := msg.(createMilestone)
 	if !ok {
 		return mi, nil
 	}
 
-	mi.state = string(milestoneLink)
+	mi.info = string(milestoneLink)
+	mi.status = state.Done
 	return mi, nil
 }
 
-func createMilestoneAct(mi menuItem) (menuItem, tea.Cmd) {
-	mi.state = "running..."
+func createMilestoneAct(mi *menuItem) (*menuItem, tea.Cmd) {
+	mi.info = "running..."
 	pl, create := pre_release.NewMilestone(mi.ctx)
 	return mi, tea.Batch(func() tea.Msg {
 		return createMilestone(create())

go/interactive/dialogue_done.go

@@ -0,0 +1,99 @@
+/*
+Copyright 2023 The Vitess Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package interactive
+
+import (
+	"fmt"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/charmbracelet/lipgloss/table"
+	"vitess.io/vitess-releaser/go/interactive/state"
+)
+
+type doneDialog struct {
+	height, width int
+	title         string
+	message       []string
+	status        *string
+}
+
+var _ tea.Model = doneDialog{}
+
+func (c doneDialog) Init() tea.Cmd {
+	return nil
+}
+
+func (c doneDialog) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg := msg.(type) {
+	case tea.WindowSizeMsg:
+		c.height = msg.Height
+		c.width = msg.Width
+		return c, nil
+
+	case tea.KeyMsg:
+		switch msg.Type {
+		case tea.KeyEnter:
+			return c, popDialog
+		case tea.KeyRunes:
+			switch string(msg.Runes) {
+			case "x":
+
+				// TODO: update the Release Issue on GitHub
+
+				if c.status == nil {
+					return c, nil
+				}
+				switch *(c.status) {
+				case state.ToDo:
+					*(c.status) = state.Done
+				case state.Done:
+					*(c.status) = state.ToDo
+				}
+			}
+		}
+	}
+
+	return c, nil
+}
+
+func (c doneDialog) View() string {
+	var rows [][]string
+	for _, s := range c.message {
+		rows = append(rows, []string{s})
+	}
+
+	s := "Unknown"
+	if c.status != nil {
+		s = *(c.status)
+	}
+
+	lines := []string{
+		c.title,
+		"",
+		fmt.Sprintf("Task status is: %s", s),
+	}
+	lines = append(lines, table.New().Data(table.NewStringData(rows...)).Width(c.width).Render())
+	lines = append(
+		lines,
+		"",
+		"Press 'x' to mark the item as Done/To do.",
+		"Press 'enter' to quit.",
+	)
+
+	return lipgloss.JoinVertical(lipgloss.Center, lines...)
+}