Use continuation instead of message to signal subcomponent results (#604)

Previously, `av sync` was using message passing to signal subcomponent
results. By sending out a special message to the bubbletea message bus,
the parent component can tell if a subcomponent finishes its process.
For example, sequencerui had three messages, Conflict, Abort, and Done,
to indicate its processing result.

While this works, it becomes complicated to handle those messages. As we
add more subcomponents, we need to handle the messages in a central
message handling function.

Instead of using message passing for signaling the results, use
continuation passing style to handle the results. This style is already
employed in the official API such as ExecProcess
(https://pkg.go.dev/github.com/charmbracelet/bubbletea#ExecProcess).

The benefit of the continuation passing style in `av` is that we can
write the processing flow from top to bottom. The passed continuation
indicates what will be done after one step. This reduces the number of
messages that we need to handle in the message handler.

Also, because `av` is doing processing step-by-step, it turned out that
we just can forward most of the messages to the last subcomponent. This
greatly simplifies the message handling code as well as the rendering
code.

Overall, this reduces the complexity of the implementation structure.

Author: draftcode

cmd/av/commit_common.go

@@ -27,19 +27,40 @@ type postCommitRestackViewModel struct {
 	repo *git.Repo
 	db   meta.DB
 
-	restackModel *sequencerui.RestackModel
+	state        *sequencerui.RestackState
+	restackModel tea.Model
 
 	quitWithConflict bool
 	err              error
 }
 
 func (vm *postCommitRestackViewModel) Init() tea.Cmd {
-	state, err := vm.createState()
+	var err error
+	vm.state, err = vm.createState()
 	if err != nil {
 		return uiutils.ErrCmd(err)
 	}
-	vm.restackModel = sequencerui.NewRestackModel(vm.repo, vm.db)
-	vm.restackModel.State = state
+	vm.restackModel = sequencerui.NewRestackModel(vm.repo, vm.db, vm.state, sequencerui.RestackStateOptions{
+		OnConflict: func() tea.Cmd {
+			if err := vm.writeState(vm.state); err != nil {
+				return uiutils.ErrCmd(err)
+			}
+			vm.quitWithConflict = true
+			return tea.Quit
+		},
+		OnAbort: func() tea.Cmd {
+			if err := vm.writeState(nil); err != nil {
+				return uiutils.ErrCmd(err)
+			}
+			return tea.Quit
+		},
+		OnDone: func() tea.Cmd {
+			if err := vm.writeState(nil); err != nil {
+				return uiutils.ErrCmd(err)
+			}
+			return tea.Quit
+		},
+	})
 	return vm.restackModel.Init()
 }
 
@@ -49,17 +70,6 @@ func (vm *postCommitRestackViewModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		var cmd tea.Cmd
 		vm.restackModel, cmd = vm.restackModel.Update(msg)
 		return vm, cmd
-	case *sequencerui.RestackConflict:
-		if err := vm.writeState(vm.restackModel.State); err != nil {
-			return vm, uiutils.ErrCmd(err)
-		}
-		vm.quitWithConflict = true
-		return vm, tea.Quit
-	case *sequencerui.RestackAbort, *sequencerui.RestackDone:
-		if err := vm.writeState(nil); err != nil {
-			return vm, uiutils.ErrCmd(err)
-		}
-		return vm, tea.Quit
 	case tea.KeyMsg:
 		switch msg.String() {
 		case "ctrl+c":

cmd/av/reparent.go

@@ -59,19 +59,40 @@ type reparentViewModel struct {
 	repo *git.Repo
 	db   meta.DB
 
-	restackModel *sequencerui.RestackModel
+	state        *sequencerui.RestackState
+	restackModel tea.Model
 
 	quitWithConflict bool
 	err              error
 }
 
 func (vm *reparentViewModel) Init() tea.Cmd {
-	state, err := vm.createState()
+	var err error
+	vm.state, err = vm.createState()
 	if err != nil {
 		return uiutils.ErrCmd(err)
 	}
-	vm.restackModel = sequencerui.NewRestackModel(vm.repo, vm.db)
-	vm.restackModel.State = state
+	vm.restackModel = sequencerui.NewRestackModel(vm.repo, vm.db, vm.state, sequencerui.RestackStateOptions{
+		OnConflict: func() tea.Cmd {
+			if err := vm.writeState(vm.state); err != nil {
+				return uiutils.ErrCmd(err)
+			}
+			vm.quitWithConflict = true
+			return tea.Quit
+		},
+		OnAbort: func() tea.Cmd {
+			if err := vm.writeState(nil); err != nil {
+				return uiutils.ErrCmd(err)
+			}
+			return tea.Quit
+		},
+		OnDone: func() tea.Cmd {
+			if err := vm.writeState(nil); err != nil {
+				return uiutils.ErrCmd(err)
+			}
+			return tea.Quit
+		},
+	})
 	return vm.restackModel.Init()
 }
 
@@ -81,17 +102,6 @@ func (vm *reparentViewModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		var cmd tea.Cmd
 		vm.restackModel, cmd = vm.restackModel.Update(msg)
 		return vm, cmd
-	case *sequencerui.RestackConflict:
-		if err := vm.writeState(vm.restackModel.State); err != nil {
-			return vm, uiutils.ErrCmd(err)
-		}
-		vm.quitWithConflict = true
-		return vm, tea.Quit
-	case *sequencerui.RestackAbort, *sequencerui.RestackDone:
-		if err := vm.writeState(nil); err != nil {
-			return vm, uiutils.ErrCmd(err)
-		}
-		return vm, tea.Quit
 	case tea.KeyMsg:
 		switch msg.String() {
 		case "ctrl+c":

cmd/av/restack.go

@@ -50,35 +50,56 @@ type restackViewModel struct {
 	repo *git.Repo
 	db   meta.DB
 
-	restackModel *sequencerui.RestackModel
+	state        *sequencerui.RestackState
+	restackModel tea.Model
 
 	quitWithConflict bool
 	err              error
 }
 
 func (vm *restackViewModel) Init() tea.Cmd {
-	state, err := vm.readState()
+	var err error
+	vm.state, err = vm.readState()
 	if err != nil {
 		return uiutils.ErrCmd(err)
 	}
-	if state == nil {
+	if vm.state == nil {
 		if restackFlags.Abort || restackFlags.Continue || restackFlags.Skip {
 			return uiutils.ErrCmd(errors.New("no restack in progress"))
 		}
-		state, err = vm.createState()
+		vm.state, err = vm.createState()
 		if err != nil {
 			return uiutils.ErrCmd(err)
 		}
 	}
-	if state == nil {
+	if vm.state == nil {
 		return uiutils.ErrCmd(nothingToRestackError)
 	}
-	vm.restackModel = sequencerui.NewRestackModel(vm.repo, vm.db)
-	vm.restackModel.State = state
-	vm.restackModel.Abort = restackFlags.Abort
-	vm.restackModel.Continue = restackFlags.Continue
-	vm.restackModel.Skip = restackFlags.Skip
-	vm.restackModel.DryRun = restackFlags.DryRun
+	vm.restackModel = sequencerui.NewRestackModel(vm.repo, vm.db, vm.state, sequencerui.RestackStateOptions{
+		Abort:    restackFlags.Abort,
+		Continue: restackFlags.Continue,
+		Skip:     restackFlags.Skip,
+		DryRun:   restackFlags.DryRun,
+		OnConflict: func() tea.Cmd {
+			if err := vm.writeState(vm.state); err != nil {
+				return uiutils.ErrCmd(err)
+			}
+			vm.quitWithConflict = true
+			return tea.Quit
+		},
+		OnAbort: func() tea.Cmd {
+			if err := vm.writeState(nil); err != nil {
+				return uiutils.ErrCmd(err)
+			}
+			return tea.Quit
+		},
+		OnDone: func() tea.Cmd {
+			if err := vm.writeState(nil); err != nil {
+				return uiutils.ErrCmd(err)
+			}
+			return tea.Quit
+		},
+	})
 	return vm.restackModel.Init()
 }
 
@@ -88,17 +109,6 @@ func (vm *restackViewModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		var cmd tea.Cmd
 		vm.restackModel, cmd = vm.restackModel.Update(msg)
 		return vm, cmd
-	case *sequencerui.RestackConflict:
-		if err := vm.writeState(vm.restackModel.State); err != nil {
-			return vm, uiutils.ErrCmd(err)
-		}
-		vm.quitWithConflict = true
-		return vm, tea.Quit
-	case *sequencerui.RestackAbort, *sequencerui.RestackDone:
-		if err := vm.writeState(nil); err != nil {
-			return vm, uiutils.ErrCmd(err)
-		}
-		return vm, tea.Quit
 	case tea.KeyMsg:
 		switch msg.String() {
 		case "ctrl+c":