Padrão Command

Parte da seção Programação Orientada a Objetos do Journey de Dart da Coddy. Lição 94 de 110.

O padrão Command encapsula uma solicitação como um objeto, permitindo parametrizar clientes com diferentes solicitações, enfileirar operações ou oferecer suporte à funcionalidade de desfazer. Em vez de chamar um método diretamente, você encapsula a ação em um objeto de comando que pode ser armazenado, transmitido ou executado posteriormente.

O padrão envolve três componentes principais: uma interface Command com um método execute, Comandos Concretos que implementam ações específicas e um Receptor que realiza o trabalho de fato. Um Invocador opcional aciona os comandos sem saber o que eles fazem:

abstract class Command {
  void execute();
}

class Light {
  void turnOn() => print('Light is ON');
  void turnOff() => print('Light is OFF');
}

class TurnOnCommand implements Command {
  final Light light;
  TurnOnCommand(this.light);

  @override
  void execute() => light.turnOn();
}

class TurnOffCommand implements Command {
  final Light light;
  TurnOffCommand(this.light);

  @override
  void execute() => light.turnOff();
}

class RemoteControl {
  Command? _command;

  void setCommand(Command command) {
    _command = command;
  }

  void pressButton() {
    _command?.execute();
  }
}

void main() {
  var light = Light();
  var remote = RemoteControl();

  remote.setCommand(TurnOnCommand(light));
  remote.pressButton();  // A luz está LIGADA

  remote.setCommand(TurnOffCommand(light));
  remote.pressButton();  // A luz está DESLIGADA
}

O RemoteControl não sabe nada sobre luzes — ele apenas executa qualquer comando que receba. Esse desacoplamento facilita a adição de novos comandos sem modificar o invocador. O padrão Command é ideal para implementar sistemas de desfazer/refazer, filas de tarefas ou gravação de macros, nos quais você precisa tratar ações como objetos de primeira classe.

Desafio

Fácil

Vamos criar um sistema de comandos para um editor de texto usando o padrão Command! Você criará um sistema que encapsula operações de texto como objetos de comando, permitindo que um editor execute diferentes ações sem conhecer os detalhes de cada operação. Este é um caso de uso clássico do padrão Command — pense nele como um sistema de desfazer/refazer, no qual cada ação é armazenada como um objeto.

Você organizará seu código em dois arquivos:

commands.dart: crie seu sistema de comandos aqui. Comece com uma classe abstrata Command que declara um método execute(). Em seguida, crie uma classe TextDocument (o receptor) que contenha um campo String content (inicialmente vazio) e tenha três métodos:
- append(String text) — adiciona texto ao final do conteúdo
- clear() — define o conteúdo como uma string vazia
- show() — imprime Document: [content]
Agora implemente três comandos concretos que funcionem com um TextDocument:
- AppendCommand — recebe um documento e um texto em seu construtor e adiciona o texto quando executado
- ClearCommand — recebe um documento em seu construtor e o limpa quando executado
- ShowCommand — recebe um documento em seu construtor e exibe seu conteúdo quando executado
Por fim, crie uma classe TextEditor (o invocador) que armazene uma lista de comandos. Ela deve ter um método addCommand(Command command) para enfileirar comandos e um método runAll() que execute todos os comandos enfileirados na ordem.
main.dart: importe seu arquivo de comandos e demonstre o padrão Command. Crie um TextDocument e um TextEditor. Enfileire os seguintes comandos, nesta ordem: adicionar Hello, adicionar World, exibir o documento, adicionar !, exibir novamente, limpar o documento e exibi-lo uma última vez. Em seguida, execute todos os comandos enfileirados.

Observe como o TextEditor não sabe nada sobre adicionar, limpar ou exibir — ele apenas executa quaisquer comandos que receba. Esse desacoplamento é a essência do padrão Command!

Saída esperada:

Document: Hello World
Document: Hello World!
Document:

Experimente você mesmo

import 'commands.dart';

void main() {
  // TODO: Crie uma instância de TextDocument

  // TODO: Crie uma instância de TextEditor

  // TODO: Enfileire os seguintes comandos em ordem:
  // 1. Adicione "Hello"
  // 2. Adicione " World"
  // 3. Mostre o documento
  // 4. Adicione "!"
  // 5. Mostre o documento novamente
  // 6. Limpe o documento
  // 7. Mostre o documento uma última vez

  // TODO: Execute todos os comandos enfileirados
}