シンプルなTodo CLIアプリ - 調査ドキュメント

1
2
3

todo add "タスク名"     -> Command::Add->execute()
todo list              -> Command::List->execute()
todo complete 1        -> Command::Complete->execute()

 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
57
58
59
60
61
62
63
64
65
66

# Command Role（インターフェース相当）
package Command::Role {
    use Moo::Role;
    requires 'execute';
    requires 'description';
}

# ConcreteCommand: タスク追加
package Command::Add {
    use Moo;
    with 'Command::Role';

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

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

    sub description { 'タスクを追加する' }
}

# ConcreteCommand: タスク一覧
package Command::List {
    use Moo;
    with 'Command::Role';

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

    sub execute {
        my $self = shift;
        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 { 'タスク一覧を表示する' }
}

# ConcreteCommand: タスク完了
package Command::Complete {
    use Moo;
    with 'Command::Role';

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

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

    sub description { 'タスクを完了にする' }
}

  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
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

# Repository Role（インターフェース相当）
package TaskRepository::Role {
    use Moo::Role;
    requires 'add';
    requires 'find';
    requires 'all';
    requires 'save';
    requires 'remove';
}

# InMemory実装（テスト用）
package TaskRepository::InMemory {
    use Moo;
    with 'TaskRepository::Role';

    has storage => (is => 'rw', default => sub { {} });
    has next_id => (is => 'rw', default => 1);

    sub add {
        my ($self, $task) = @_;
        my $id = $self->next_id;
        $task->id($id);
        $self->storage->{$id} = $task;
        $self->next_id($id + 1);
        return $task;
    }

    sub find {
        my ($self, $id) = @_;
        return $self->storage->{$id};
    }

    sub all {
        my $self = shift;
        return values %{$self->storage};
    }

    sub save {
        my ($self, $task) = @_;
        $self->storage->{$task->id} = $task;
    }

    sub remove {
        my ($self, $id) = @_;
        delete $self->storage->{$id};
    }
}

# JSON File実装
package TaskRepository::File {
    use Moo;
    use JSON;
    with 'TaskRepository::Role';

    has filepath => (is => 'ro', default => 'tasks.json');

    sub _load {
        my $self = shift;
        return [] unless -f $self->filepath;
        open my $fh, '<:encoding(UTF-8)', $self->filepath or die $!;
        local $/;
        my $json = <$fh>;
        close $fh;
        return decode_json($json);
    }

    sub _save_all {
        my ($self, $data) = @_;
        open my $fh, '>:encoding(UTF-8)', $self->filepath or die $!;
        print $fh encode_json($data);
        close $fh;
    }

    sub add {
        my ($self, $task) = @_;
        my $data = $self->_load;
        my $max_id = 0;
        for my $item (@$data) {
            $max_id = $item->{id} if $item->{id} > $max_id;
        }
        $task->id($max_id + 1);
        push @$data, {
            id      => $task->id,
            title   => $task->title,
            is_done => $task->is_done ? 1 : 0,
        };
        $self->_save_all($data);
        return $task;
    }

    sub find {
        my ($self, $id) = @_;
        my $data = $self->_load;
        for my $item (@$data) {
            if ($item->{id} == $id) {
                return Task->new(%$item);
            }
        }
        return;
    }

    sub all {
        my $self = shift;
        my $data = $self->_load;
        return map { Task->new(%$_) } @$data;
    }

    sub save {
        my ($self, $task) = @_;
        my $data = $self->_load;
        for my $item (@$data) {
            if ($item->{id} == $task->id) {
                $item->{title}   = $task->title;
                $item->{is_done} = $task->is_done ? 1 : 0;
                last;
            }
        }
        $self->_save_all($data);
    }

    sub remove {
        my ($self, $id) = @_;
        my $data = $self->_load;
        @$data = grep { $_->{id} != $id } @$data;
        $self->_save_all($data);
    }
}

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

use Getopt::Long;
use Pod::Usage;

my %opts = (
    verbose => 0,
);

GetOptions(
    'verbose|v' => \$opts{verbose},
    'help|h'    => sub { pod2usage(-verbose => 1) },
) or pod2usage(-verbose => 1);

# 残りの引数は @ARGV に残る
my $command = shift @ARGV // 'help';
my @args    = @ARGV;

 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

#!/usr/bin/env perl
use strict;
use warnings;
use Getopt::Long;

# サブコマンドを取得
my $command = shift @ARGV // 'help';

# サブコマンドに応じて処理を分岐
if ($command eq 'add') {
    my $title = shift @ARGV;
    die "タスク名を指定してください\n" unless $title;
    # Command::Add->new(title => $title, repository => $repo)->execute;
}
elsif ($command eq 'list') {
    # Command::List->new(repository => $repo)->execute;
}
elsif ($command eq 'complete') {
    my $id = shift @ARGV;
    die "タスクIDを指定してください\n" unless $id;
    # Command::Complete->new(task_id => $id, repository => $repo)->execute;
}
else {
    print "使い方: todo <command> [args]\n";
    print "  add <title>     タスクを追加\n";
    print "  list            タスク一覧を表示\n";
    print "  complete <id>   タスクを完了にする\n";
}

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

use JSON;

# 書き込み
sub save_to_json {
    my ($filepath, $data) = @_;
    open my $fh, '>:encoding(UTF-8)', $filepath or die $!;
    print $fh encode_json($data);
    close $fh;
}

# 読み込み
sub load_from_json {
    my ($filepath) = @_;
    return [] unless -f $filepath;
    open my $fh, '<:encoding(UTF-8)', $filepath or die $!;
    local $/;  # スラープモード
    my $json = <$fh>;
    close $fh;
    return decode_json($json);
}

1
2
3
4
5

[
  { "id": 1, "title": "買い物に行く", "is_done": false },
  { "id": 2, "title": "レポートを書く", "is_done": true },
  { "id": 3, "title": "Perlの勉強", "is_done": false }
]

 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

use DBI;

# 接続
my $dbh = DBI->connect("dbi:SQLite:dbname=tasks.db", "", "", {
    PrintError => 0,
    RaiseError => 1,
    AutoCommit => 1,
}) or die $DBI::errstr;

# テーブル作成
$dbh->do(q{
    CREATE TABLE IF NOT EXISTS tasks (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        title TEXT NOT NULL,
        is_done INTEGER DEFAULT 0
    )
});

# INSERT
$dbh->do("INSERT INTO tasks (title) VALUES (?)", undef, "新しいタスク");

# SELECT
my $sth = $dbh->prepare("SELECT id, title, is_done FROM tasks");
$sth->execute();
while (my @row = $sth->fetchrow_array) {
    print "ID:$row[0] Title:$row[1] Done:$row[2]\n";
}

# UPDATE
$dbh->do("UPDATE tasks SET is_done = 1 WHERE id = ?", undef, 1);

# DELETE
$dbh->do("DELETE FROM tasks WHERE id = ?", undef, 1);

$dbh->disconnect;