Patrón Command

Parte de la sección Programación Orientada a Objetos del Journey de GO de Coddy. Lección 91 de 107.

El patrón Command encapsula una solicitud como un objeto, lo que te permite parametrizar operaciones, ponerlas en cola o admitir la funcionalidad de deshacer. Mientras que Strategy encapsula algoritmos, Command encapsula acciones completas junto con sus parámetros.

En Go, definimos una interfaz Command con un método Execute, después creamos comandos concretos que contienen toda la información necesaria para realizar una acción:

type Command interface {
    Execute() string
}

type Light struct {
    IsOn bool
}

type TurnOnCommand struct {
    light *Light
}

func (c *TurnOnCommand) Execute() string {
    c.light.IsOn = true
    return "Light turned on"
}

type TurnOffCommand struct {
    light *Light
}

func (c *TurnOffCommand) Execute() string {
    c.light.IsOn = false
    return "Light turned off"
}

Un invocador almacena y ejecuta comandos sin saber qué hacen:

type RemoteControl struct {
    command Command
}

func (r *RemoteControl) SetCommand(c Command) {
    r.command = c
}

func (r *RemoteControl) PressButton() string {
    return r.command.Execute()
}

El invocador está completamente desacoplado del receptor (la luz):

light := &Light{}
remote := &RemoteControl{}

remote.SetCommand(&TurnOnCommand{light: light})
fmt.Println(remote.PressButton())  // Luz encendida

remote.SetCommand(&TurnOffCommand{light: light})
fmt.Println(remote.PressButton())  // Luz apagada

Command es ideal para implementar sistemas de deshacer/rehacer, colas de tareas o grabación de macros cuando necesitas almacenar, retrasar o reproducir operaciones.

Desafío

Fácil

¡Construyamos un editor de texto con funcionalidad de deshacer usando el patrón Command! Crearás comandos que encapsulan operaciones de texto, lo que permite al editor ejecutar acciones y revertirlas: un caso de uso clásico que demuestra por qué los comandos son tan potentes.

Organizarás tu código en tres archivos:

command.go: Define tu interfaz de comandos y los comandos concretos de edición de texto.
Crea una interfaz Command con dos métodos: Execute() string para realizar la acción y Undo() string para revertirla.

Implementa dos tipos de comandos que operen sobre un *TextEditor:
- InsertCommand: contiene el puntero al editor y el texto que se insertará. Execute agrega el texto al contenido del editor y devuelve Inserted: [text]. Undo elimina ese texto del final y devuelve Undone insert: [text]
- DeleteCommand: contiene el puntero al editor y una cantidad de caracteres que se eliminarán del final. Execute elimina esos caracteres (guardándolos para deshacer) y devuelve Deleted: [removed text]. Undo los restaura y devuelve Undone delete: [restored text]
editor.go: Crea tu editor de texto (el receptor) y el invocador que administra el historial de comandos.
Construye una estructura TextEditor con un campo Content (string) y métodos Append(text string) y DeleteLast(count int) string (devuelve el texto eliminado).

Construye una estructura EditorInvoker que contenga un slice de comandos ejecutados como historial. Agrega estos métodos:
- ExecuteCommand(cmd Command) string: ejecuta el comando, lo agrega al historial y devuelve el resultado
- UndoLast() string: elimina el último comando del historial, llama a su Undo y devuelve el resultado. Si el historial está vacío, devuelve Nothing to undo
main.go: Demuestra tu sistema de comandos con una serie de operaciones.
Lee una cantidad de operaciones. Para cada operación, lee el tipo de operación (insert, delete o undo). Para insert, lee también el texto que se insertará. Para delete, lee la cantidad de caracteres. Ejecuta cada operación mediante tu invocador e imprime el resultado. Después de todas las operaciones, imprime el contenido final del editor como Final: [content].

Se proporcionarán las siguientes entradas:

Línea 1: Número de operaciones
Para cada operación: tipo de operación, después los datos adicionales si son necesarios (texto para insert, cantidad para delete)

Por ejemplo, dada la siguiente entrada:

5
insert
Hello
insert
 World
delete
3
undo
undo

Tu salida debería ser:

Inserted: Hello
Inserted:  World
Deleted: rld
Undone delete: rld
Undone insert:  World
Final: Hello

Y dada la siguiente entrada:

4
insert
Go
insert
Lang
undo
insert
!

Tu salida debería ser:

Inserted: Go
Inserted: Lang
Undone insert: Lang
Inserted: !
Final: Go!

Y dada la siguiente entrada:

2
undo
insert
Test

Tu salida debería ser:

Nothing to undo
Inserted: Test
Final: Test

Observa cómo cada comando encapsula todo lo necesario tanto para realizar como para revertir su acción. El invocador no sabe qué hacen los comandos. ¡Simplemente los ejecuta y mantiene el historial para permitir deshacer!

Pruébalo tú mismo

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	
	// Leer el número de operaciones
	line, _ := reader.ReadString('\n')
	numOps, _ := strconv.Atoi(strings.TrimSpace(line))
	
	// Crear el editor y el invoker
	editor := &TextEditor{}
	invoker := &EditorInvoker{}
	
	for i := 0; i < numOps; i++ {
		// Leer el tipo de operación
		opLine, _ := reader.ReadString('\n')
		opType := strings.TrimSpace(opLine)
		
		var result string
		
		switch opType {
		case "insert":
			// Leer el texto a insertar
			textLine, _ := reader.ReadString('\n')
			text := strings.TrimSuffix(textLine, "\n")
			
			// TODO: Crear un InsertCommand y ejecutarlo a través del invoker
			_ = text
			_ = editor
			
		case "delete":
			// Leer la cantidad de caracteres a eliminar
			countLine, _ := reader.ReadString('\n')
			count, _ := strconv.Atoi(strings.TrimSpace(countLine))
			
			// TODO: Crear un DeleteCommand y ejecutarlo a través del invoker
			_ = count
			
		case "undo":
			// TODO: Llamar a UndoLast en el invoker
			
		}
		
		fmt.Println(result)
	}
	
	// Imprimir el contenido final
	fmt.Printf("Final: %s\n", editor.Content)
}