QBit/Validator/Type/hash.pm untested

filter: Statementstmt 0.0% 0 / 116 Branchbran 0.0% 0 / 46 Conditioncond 0.0% 0 / 16 MC/DCmcdc 0.0% 0 / 9 Subroutinesub 0.0% 0 / 15 Podpod 0.0% 0 / 11 totaltotal 0.0% 0 / 213 CC 24 SCAR 32.0
CC
24
Cov
0%
deps
42.0
one_of
42.0
any_of
42.0
CRAP 24.6
1 package QBit::Validator::Type::hash;
2 $QBit::Validator::Type::hash::VERSION = '0.012';
3 use qbit;
4  
5 use base qw(QBit::Validator::Type);
6  
7 use Exception::Validator;
8 use Exception::Validator::FailedField;
9  
10 #order is important
11 sub get_options_name {
12 qw(type deps fields one_of any_of extra);
13 }
14  
15 sub pre_process_template {
16 my ($self, $template) = @_;
17  
18 $template->{'extra'} //= FALSE;
19 }
20  
21 sub type {
22 my ($qv, $types) = @_;
23  
24 return sub {
25 throw FF gettext('Data must be HASH') if ref($_[1]) ne 'HASH';
26  
27 return TRUE;
28 }
29 }
30  
31 sub deps {
32 my ($qv, $depends, $template) = @_;
33  
34 throw Exception::Validator gettext('Option "%s" must be HASH', 'deps') unless ref($depends) eq 'HASH';
35  
36 throw Exception::Validator gettext('You must specify option "%s"', 'fields') unless exists($template->{'fields'});
37  
38 my $inverse_depends = $qv->{'__INVERSE_DEPENDS__'} = {};
39 foreach my $field (keys(%$depends)) {
40 my $deps = $depends->{$field};
41  
42 throw Exception::Validator gettext('You must specify the fields on which the field "%s"', $field)
43 unless defined($deps);
44  
45 if (ref($deps) ne 'ARRAY') {
46 $depends->{$field} = $deps = [$deps];
47 }
48  
49 my @unknown_fields = grep {!exists($template->{'fields'}{$_})} @$deps;
50  
51 throw Exception::Validator gettext('Keys: %s do not used in option "fields"', join(', ', @unknown_fields))
52 if @unknown_fields;
53  
54 foreach (@$deps) {
55 push(@{$inverse_depends->{$_}}, $field);
56 }
57 }
58  
59 my $order = $qv->{'__FIELDS_ORDER__'} = {};
60 foreach my $field (keys(%{$template->{'fields'}})) {
61 $order->{$field} = _get_field_order($field, $order, $depends);
62 }
63  
64 return ();
65 }
66  
67 sub _get_field_order {
68 #my ($field, $order, $deps) = @_;
69  
70 return $_[1]->{$_[0]} if defined($_[1]->{$_[0]});
71  
72 if ($_[2]->{$_[0]}) {
73 return array_n_max(map {$_[1]->{$_} = _get_field_order($_, $_[1], $_[2])} @{$_[2]->{$_[0]}}) + 1;
74 } else {
75 return 0;
76 }
77 }
78  
79 #TODO: implement method _exists
80 # defined = required
81  
82 sub fields {
83 my ($qv, $fields, $template) = @_;
84  
85 my $parent = $qv->parent // $qv;
86 my $path_manager = $parent->path_manager();
87  
88 my $path = $qv->path();
89  
90 my %validators = ();
91 foreach my $field (keys(%$fields)) {
92 $validators{$field} = QBit::Validator->new(
93 template => $fields->{$field},
94 parent => $parent,
95 path => $path_manager->get_absolute_path($path_manager->get_path_part('hash', $field), $path),
96 );
97 }
98  
99 my $inverse_depends = $qv->{'__INVERSE_DEPENDS__'} // {};
100  
101 my $order = $qv->{'__FIELDS_ORDER__'} // {};
102 my @sorted_fields = sort {($order->{$a} // 0) <=> ($order->{$b} // 0)} keys(%$fields);
103  
104 return sub {
105 my %errors = ();
106 foreach my $field (@sorted_fields) {
107 next if $errors{$field};
108  
109 unless ($validators{$field}->_validate($_[1]->{$field})) {
110 $errors{$field} = $validators{$field}->get_errors;
111  
112 _set_recursive_depends_errors($field, \%errors, $inverse_depends);
113 }
114 }
115  
116 throw FF \%errors if %errors;
117  
118 return TRUE;
119 }
120 }
121  
122 sub _set_recursive_depends_errors {
123 #my ($field, $errors, $inverse_depends) = @_;
124  
125 foreach (@{$_[2]->{$_[0]} // []}) {
126 $_[1]->{$_} = gettext('Field "%s" depends on "%s"', $_, $_[0]);
127  
128 _set_recursive_depends_errors($_, $_[1], $_[2]);
129 }
130 }
131  
132 sub extra {
133 my ($qv, $val, $template) = @_;
134  
135 unless ($val) {
136 return sub {
137 my @extra_fields = grep {!$template->{'fields'}{$_}} keys(%{$_[1]});
138  
139 if (@extra_fields) {
140 throw FF gettext('Extra fields: %s', join(', ', @extra_fields));
141 }
142  
143 return TRUE;
144 }
145 }
146  
147 return ();
148 }
149  
150 sub one_of {
151 my ($qv, $list, $template) = @_;
152  
153 throw Exception::Validator gettext('Option "%s" must be ARRAY', 'one_of')
154 if ref($list) ne 'ARRAY';
155  
156 my $min_size = 2;
157  
158 throw Exception::Validator gettext('Option "%s" have size "%s", but expected size equal or more than "%s"',
159 'one_of', scalar(@$list), $min_size)
160 if @$list < $min_size;
161  
162 my @unknow_fields = grep {!exists($template->{'fields'}{$_})} @$list;
163 if (@unknow_fields) {
164 throw Exception::Validator gettext('Keys: %s do not used in option "fields"', join(', ', @unknow_fields));
165 }
166  
167 return sub {
168 my @received_fields = ();
169 foreach my $field (@$list) {
170 push(@received_fields, $field) if exists($_[1]->{$field});
171 }
172  
173 if (@received_fields != 1) {
174 throw FF gettext('Expected one key from: %s', join(', ', $list));
175 }
176  
177 return TRUE;
178 };
179 }
180  
181 sub any_of {
182 my ($qv, $list, $template) = @_;
183  
184 throw Exception::Validator gettext('Option "%s" must be ARRAY', 'any_of')
185 if ref($list) ne 'ARRAY';
186  
187 my $min_size = 2;
188  
189 throw Exception::Validator gettext('Option "%s" have size "%s", but expected size equal or more than "%s"',
190 'any_of', scalar(@$list), $min_size)
191 if @$list < $min_size;
192  
193 my @unknow_fields = grep {!exists($template->{'fields'}{$_})} @$list;
194 if (@unknow_fields) {
195 throw Exception::Validator gettext('Keys: %s do not used in option "fields"', join(', ', @unknow_fields));
196 }
197  
198 return sub {
199 my @received_fields = ();
200 foreach my $field (@$list) {
201 push(@received_fields, $field) if exists($_[1]->{$field});
202 }
203  
204 unless (@received_fields) {
205 throw FF gettext('Expected any keys from: %s', join(', ', $list));
206 }
207  
208 return TRUE;
209 };
210 }
211  
212 sub init {
213 my ($self) = @_;
214  
215 $self->SUPER::init();
216  
217 foreach ($self->get_options_name) {
218 $self->{$_} = \&$_;
219 }
220 }
221  
222 TRUE;