1
2
3
4
5
6

{
  "jsonrpc": "2.0",
  "method": "sum",
  "params": [42, 23],
  "id": 1
}

1
2
3
4
5

{
  "jsonrpc": "2.0",
  "result": 65,
  "id": 1
}

1
2
3
4
5
6
7
8

{
  "jsonrpc": "2.0",
  "error": {
    "code": -32600,
    "message": "Invalid Request"
  },
  "id": null
}

1
2
3
4
5

{
  "code": -32600,
  "message": "Invalid Request",
  "data": "Additional error information"
}

1
2
3
4
5

has jsonrpc => (
    is       => 'ro',  # 読み取り専用 = 不変
    default  => '2.0',
    required => 1,
);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# すべてのフィールドが初期化されている
my $request = JsonRpcRequest->new(
    jsonrpc => '2.0',
    method  => 'sum',
    params  => [42, 23],
    id      => 1,
);

# 後から変更できない（コンパイルエラー）
# $request->method('multiply');  # エラー！

1
2
3
4
5
6

has jsonrpc => (
    is  => 'ro',
    isa => sub {
        die "jsonrpc MUST be '2.0'" unless $_[0] eq '2.0';
    },
);

1
2
3
4

has params => (
    is        => 'ro',
    predicate => 'has_params',  # 存在チェック用メソッド
);

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

# 悪い例: 文字列を直接使う
sub send_request {
    my ($method, $params, $id) = @_;
    my $request = {
        jsonrpc => '2.0',  # ここでタイポしたら？
        method  => $method,
        params  => $params,
        id      => $id,
    };
    # ...
}

# タイポの例
my $request = { jsonrpc => '2.1' };  # バグだが、気づきにくい

1
2
3
4
5
6

# 良い例: 値オブジェクトを使う
my $version = JsonRpcVersion->new();  # 常に "2.0"
my $request = {
    jsonrpc => $version->value,
    # ...
};

 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

package JsonRpc::Version;
use v5.38;
use Moo;
use namespace::clean;

# プロトコルバージョン（常に "2.0"）
has value => (
    is      => 'ro',
    default => '2.0',
    isa     => sub {
        die "JSON-RPC version MUST be '2.0', got '$_[0]'"
            unless defined $_[0] && $_[0] eq '2.0';
    },
);

# 値による等価性
sub equals {
    my ($self, $other) = @_;
    return 0 unless $other->isa(__PACKAGE__);
    return $self->value eq $other->value;
}

# 文字列化
sub to_string {
    my $self = shift;
    return $self->value;
}

1;

__END__

=head1 NAME

JsonRpc::Version - JSON-RPC protocol version value object

=head1 SYNOPSIS

    use JsonRpc::Version;
    
    # Create version object (always "2.0")
    my $version = JsonRpc::Version->new();
    say $version->value;  # "2.0"
    
    # Attempting to create with invalid version fails
    eval {
        my $invalid = JsonRpc::Version->new(value => '1.0');
    };
    say $@ if $@;  # Error: JSON-RPC version MUST be '2.0'

=head1 DESCRIPTION

This module implements a value object for JSON-RPC 2.0 protocol version.
According to the JSON-RPC 2.0 specification, the version MUST be exactly "2.0".

This value object ensures:

=over 4

=item * Immutability - version cannot be changed after creation

=item * Validity - only "2.0" is accepted

=item * Type safety - prevents typos and invalid versions

=back

=head1 METHODS

=head2 value

Returns the protocol version string (always "2.0").

=head2 equals($other)

Compares this version with another Version object for equality.

=head2 to_string

Returns the string representation of the version.

=head1 SPECIFICATION

L<https://www.jsonrpc.org/specification>

=cut

 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

use Test2::V0;
use lib 'lib';
use JsonRpc::Version;

subtest 'default construction creates valid version' => sub {
    my $version = JsonRpc::Version->new();
    
    ok $version, 'version object created';
    is $version->value, '2.0', 'version is "2.0"';
    is $version->to_string, '2.0', 'to_string returns "2.0"';
};

subtest 'explicit version "2.0" is accepted' => sub {
    my $version = JsonRpc::Version->new(value => '2.0');
    
    ok $version, 'version object created with explicit value';
    is $version->value, '2.0', 'version is "2.0"';
};

subtest 'invalid versions are rejected' => sub {
    subtest 'version "1.0" is rejected' => sub {
        like(
            dies { JsonRpc::Version->new(value => '1.0') },
            qr/JSON-RPC version MUST be '2\.0'/,
            'version 1.0 throws error'
        );
    };
    
    subtest 'version "2.1" is rejected' => sub {
        like(
            dies { JsonRpc::Version->new(value => '2.1') },
            qr/JSON-RPC version MUST be '2\.0'/,
            'version 2.1 throws error'
        );
    };
    
    subtest 'empty string is rejected' => sub {
        like(
            dies { JsonRpc::Version->new(value => '') },
            qr/JSON-RPC version MUST be '2\.0'/,
            'empty string throws error'
        );
    };
    
    subtest 'undef is rejected' => sub {
        like(
            dies { JsonRpc::Version->new(value => undef) },
            qr/JSON-RPC version MUST be '2\.0'/,
            'undef throws error'
        );
    };
};

subtest 'immutability' => sub {
    my $version = JsonRpc::Version->new();
    
    like(
        dies { $version->value('3.0') },
        qr/Usage:/,
        'cannot modify version (read-only)'
    );
};

subtest 'equality comparison' => sub {
    my $version1 = JsonRpc::Version->new();
    my $version2 = JsonRpc::Version->new();
    
    ok $version1->equals($version2), 
        'two version objects are equal';
    
    # 同じ値なので等価
    ok $version1->equals($version1), 
        'version equals itself';
};

subtest 'value object characteristics' => sub {
    my $v1 = JsonRpc::Version->new();
    my $v2 = JsonRpc::Version->new();
    
    # 値による等価性
    ok $v1->equals($v2), 'equality by value';
    
    # 不変性
    is $v1->value, '2.0', 'immutable value preserved';
    
    # 型安全性
    ok $v1->isa('JsonRpc::Version'), 'correct type';
};

done_testing;

1
2
3
4
5

has value => (
    is      => 'ro',
    default => '2.0',  # デフォルト値を指定
    # ...
);

1
2
3
4

isa => sub {
    die "JSON-RPC version MUST be '2.0', got '$_[0]'"
        unless defined $_[0] && $_[0] eq '2.0';
},

 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

$ prove -lv t/jsonrpc/version.t
t/jsonrpc/version.t .. 
    # Subtest: default construction creates valid version
    ok 1 - version object created
    ok 2 - version is "2.0"
    ok 3 - to_string returns "2.0"
    1..3
ok 1 - default construction creates valid version
    # Subtest: explicit version "2.0" is accepted
    ok 1 - version object created with explicit value
    ok 2 - version is "2.0"
    1..2
ok 2 - explicit version "2.0" is accepted
    # Subtest: invalid versions are rejected
        # Subtest: version "1.0" is rejected
        ok 1 - version 1.0 throws error
        1..1
    ok 1 - version "1.0" is rejected
    # ... (以下略)
ok 3 - invalid versions are rejected
ok 4 - immutability
ok 5 - equality comparison
ok 6 - value object characteristics
1..6
ok
All tests successful.

1
2
3
4
5
6
7
8
9

1. 仕様書を読む
   ↓
2. MUST/SHOULD/MAYで制約を抽出
   ↓
3. 制約を型とバリデーションルールに変換
   ↓
4. 不変性と値による等価性を実装
   ↓
5. 網羅的なテストで検証