Commandパターン調査ドキュメント

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

package Command::Role {
    use Moo::Role;
    
    # 必須メソッドの宣言
    requires 'execute';      # コマンドの実行
    requires 'description';  # コマンドの説明（ヘルプ表示用）
    
    # オプション：Undo対応の場合
    # requires 'undo';
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

package Command::Add {
    use Moo;
    use v5.36;
    with 'Command::Role';

    has repository => (is => 'ro', required => 1);
    has title      => (is => 'ro', required => 1);

    sub execute ($self) {
        my $task = Task->new(title => $self->title);
        $self->repository->add($task);
        say "タスクを追加しました: " . $self->title;
    }

    sub description ($self) { 'タスクを追加する' }
}

package Command::List {
    use Moo;
    use v5.36;
    with 'Command::Role';

    has repository => (is => 'ro', required => 1);

    sub execute ($self) {
        my @tasks = $self->repository->all;
        for my $task (@tasks) {
            my $status = $task->is_done ? '[x]' : '[ ]';
            printf "%d. %s %s\n", $task->id, $status, $task->title;
        }
    }

    sub description ($self) { 'タスク一覧を表示する' }
}

package Command::Complete {
    use Moo;
    use v5.36;
    with 'Command::Role';

    has repository => (is => 'ro', required => 1);
    has task_id    => (is => 'ro', required => 1);

    sub execute ($self) {
        my $task = $self->repository->find($self->task_id);
        if ($task) {
            $task->mark_done;
            $self->repository->save($task);
            say "タスクを完了しました: " . $task->title;
        } else {
            say "タスクが見つかりません: ID " . $self->task_id;
        }
    }

    sub description ($self) { 'タスクを完了にする' }
}

1
2
3
4

sub execute {
    my $self = shift;
    # 処理
}

1
2
3

sub execute ($self) {
    # 処理
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

package TodoApp {
    use Moo;
    use v5.36;

    has repository => (is => 'ro', required => 1);
    
    sub run ($self, @args) {
        my $command_name = shift @args // 'help';
        
        my $command = $self->_create_command($command_name, @args);
        
        if ($command) {
            $command->execute;
        } else {
            $self->_show_help;
        }
    }
    
    sub _create_command ($self, $name, @args) {
        my %commands = (
            add      => sub { 
                Command::Add->new(
                    repository => $self->repository,
                    title      => $args[0] // die "タスク名を指定してください\n",
                );
            },
            list     => sub {
                Command::List->new(repository => $self->repository);
            },
            complete => sub {
                Command::Complete->new(
                    repository => $self->repository,
                    task_id    => $args[0] // die "タスクIDを指定してください\n",
                );
            },
        );
        
        return exists $commands{$name} ? $commands{$name}->() : undef;
    }
    
    sub _show_help ($self) {
        say "使い方: todo <command> [args]";
        say "  add <title>     タスクを追加";
        say "  list            タスク一覧を表示";
        say "  complete <id>   タスクを完了にする";
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 良い例：各コマンドは1つの責任のみ
package Command::Add { ... }       # タスク追加のみ
package Command::List { ... }      # タスク一覧のみ
package Command::Complete { ... }  # タスク完了のみ

# 悪い例：1つのクラスに複数の責任
package TodoCommands {
    sub add { ... }
    sub list { ... }
    sub complete { ... }
    # 変更理由が3つある → SRP違反
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# 新しいコマンドを追加しても、既存コードは変更不要
package Command::Delete {
    use Moo;
    with 'Command::Role';
    
    has repository => (is => 'ro', required => 1);
    has task_id    => (is => 'ro', required => 1);

    sub execute ($self) {
        $self->repository->remove($self->task_id);
        say "タスクを削除しました";
    }

    sub description ($self) { 'タスクを削除する' }
}

# Invokerへの登録のみ追加（既存コマンドは影響なし）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 抽象（Command Role）に依存
has command => (
    is   => 'ro',
    isa => sub { # 具体的なクラスではなく、Roleに依存
        my $value = shift;
        die "exporter must does Command::Role" unless $value->does('Command::Role')
    },
);

# テスト時にモックコマンドを注入可能
my $mock_command = MockCommand->new;
$invoker->command($mock_command);

1
2
3
4
5

todo add "タスク名"     -> Command::Add->execute()
todo list              -> Command::List->execute()
todo complete 1        -> Command::Complete->execute()
todo delete 1          -> Command::Delete->execute()
todo help              -> ヘルプ表示

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

package CommandHistory {
    use Moo;
    use v5.36;

    has undo_stack => (is => 'rw', default => sub { [] });
    has redo_stack => (is => 'rw', default => sub { [] });

    sub execute_command ($self, $command) {
        $command->execute;
        push @{$self->undo_stack}, $command;
        $self->redo_stack([]);  # 新しい操作でredoスタックをクリア
    }

    sub undo ($self) {
        return unless @{$self->undo_stack};
        my $command = pop @{$self->undo_stack};
        $command->undo;
        push @{$self->redo_stack}, $command;
    }

    sub redo ($self) {
        return unless @{$self->redo_stack};
        my $command = pop @{$self->redo_stack};
        $command->execute;
        push @{$self->undo_stack}, $command;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

package Command::InsertText {
    use Moo;
    use v5.36;
    with 'Command::Role';

    has editor   => (is => 'ro', required => 1);
    has text     => (is => 'ro', required => 1);
    has position => (is => 'ro', required => 1);

    sub execute ($self) {
        $self->editor->insert($self->text, $self->position);
    }

    sub undo ($self) {
        $self->editor->delete($self->position, length($self->text));
    }

    sub description ($self) { 'テキストを挿入する' }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

package Macro {
    use Moo;
    use v5.36;
    with 'Command::Role';

    has commands => (is => 'rw', default => sub { [] });

    sub add_command ($self, $command) {
        push @{$self->commands}, $command;
    }

    sub execute ($self) {
        $_->execute for @{$self->commands};
    }

    sub undo ($self) {
        # 逆順でundo
        $_->undo for reverse @{$self->commands};
    }

    sub description ($self) { 'マクロを実行する' }
}

# 使用例
my $macro = Macro->new;
$macro->add_command(Command::InsertText->new(...));
$macro->add_command(Command::InsertText->new(...));
$macro->execute;  # 複数のコマンドを一括実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

package JobQueue {
    use Moo;
    use v5.36;

    has queue => (is => 'rw', default => sub { [] });

    sub enqueue ($self, $command) {
        push @{$self->queue}, $command;
    }

    sub process ($self) {
        while (my $command = shift @{$self->queue}) {
            eval {
                $command->execute;
            };
            if ($@) {
                warn "コマンド実行エラー: $@";
            }
        }
    }
}