1. Definition

The Command Design Pattern encapsulates a request as an object, thereby allowing for parameterization of clients with different requests, queuing of requests, and logging the operations. It also provides support for undoable operations.

2. Problem Statement

Consider a scenario where you have various operations or requests, and you want to decouple the objects that invoke these operations from the objects that perform them. You might also want the flexibility to queue, log, or support undo-redo functionalities for these operations.

3. Solution

Command pattern introduces command objects. Each command object knows how to perform an operation, and it decouples the invoker from the receiver. You can queue commands, log them, or even implement undo and redo features.

4. Real-World Use Cases

1. Remote control system where each button press is a command.

2. Task scheduling or job queue systems.

3. Undo-redo functionality in software like word processors or graphic editors.

5. Implementation Steps

1. Define a command interface with an 'execute' method.

2. Create one or more concrete classes that implement this command interface for specific actions.

3. Define an invoker class to keep and execute these commands.

6. Implementation in Ruby

# Step 1: Command Interface class Command def execute raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'" end end # Step 2: Concrete Command Classes class LightOnCommand < Command def initialize(light) @light = light end def execute @light.turn_on end end class LightOffCommand < Command def initialize(light) @light = light end def execute @light.turn_off end end # Receiver class class Light def turn_on "Light is ON" end def turn_off "Light is OFF" end end # Step 3: Invoker Class class RemoteControl def submit(command) command.execute end end # Client code light = Light.new turn_on = LightOnCommand.new(light) turn_off = LightOffCommand.new(light) remote = RemoteControl.new puts remote.submit(turn_on) puts remote.submit(turn_off) 

Output:

Light is ON Light is OFF 

Explanation:

1. Command is an interface that declares the execute method.

2. LightOnCommand and LightOffCommand are concrete commands that encapsulate a request to a Light object.

3. RemoteControl is an invoker. It asks the command to carry out the request.

4. In the client code, we initialize a Light, wrap its on and off operations with respective commands, and then use a RemoteControl to invoke these commands.

7. When to use?

Use the Command Pattern when:

1. You need to decouple an object that invokes an operation from the one that knows how to perform it.

2. You want to support undo, redo, or other queue and logging operations.

3. You want to parameterize objects with operations.