has
id
=>
sub
{
my
$data
=
shift
->data;
return
is_type(
$data
,
'HASH'
) ?
$data
->{
'$id'
} ||
''
:
''
;
};
sub
_build_formats {
return
{
'date-time'
=> JSON::Validator::Formats->can(
'check_date_time'
),
'email'
=> JSON::Validator::Formats->can(
'check_email'
),
'hostname'
=> JSON::Validator::Formats->can(
'check_hostname'
),
'ipv4'
=> JSON::Validator::Formats->can(
'check_ipv4'
),
'ipv6'
=> JSON::Validator::Formats->can(
'check_ipv6'
),
'json-pointer'
=> JSON::Validator::Formats->can(
'check_json_pointer'
),
'regex'
=> JSON::Validator::Formats->can(
'check_regex'
),
'relative-json-pointer'
=> JSON::Validator::Formats->can(
'check_relative_json_pointer'
),
'uri'
=> JSON::Validator::Formats->can(
'check_uri'
),
'uri-reference'
=> JSON::Validator::Formats->can(
'check_uri_reference'
),
'uri-template'
=> JSON::Validator::Formats->can(
'check_uri_template'
),
};
}
sub
_id_key {
'$id'
}
sub
_validate_number_max {
my
(
$self
,
$value
,
$path
,
$schema
,
$expected
) =
@_
;
my
$cmp_with
=
$schema
->{maximum};
return
E
$path
, [
$expected
=>
maximum
=>
$value
,
$cmp_with
]
if
defined
$cmp_with
and
$value
>
$cmp_with
;
$cmp_with
=
$schema
->{exclusiveMaximum};
return
E
$path
, [
$expected
=>
ex_maximum
=>
$value
,
$cmp_with
]
if
defined
$cmp_with
and
$value
>=
$cmp_with
;
return
;
}
sub
_validate_number_min {
my
(
$self
,
$value
,
$path
,
$schema
,
$expected
) =
@_
;
my
$cmp_with
=
$schema
->{minimum};
return
E
$path
, [
$expected
=>
minimum
=>
$value
,
$cmp_with
]
if
defined
$cmp_with
and
$value
<
$cmp_with
;
$cmp_with
=
$schema
->{exclusiveMinimum};
return
E
$path
, [
$expected
=>
ex_minimum
=>
$value
,
$cmp_with
]
if
defined
$cmp_with
and
$value
<=
$cmp_with
;
return
;
}
sub
_validate_type_array {
my
(
$self
,
$data
,
$path
,
$schema
) =
@_
;
return
E
$path
, [
array
=>
type
=> data_type
$data
]
if
ref
$data
ne
'ARRAY'
;
return
(
$self
->_validate_type_array_min_max(
$_
[1],
$path
,
$schema
),
$self
->_validate_type_array_unique(
$_
[1],
$path
,
$schema
),
$self
->_validate_type_array_contains(
$_
[1],
$path
,
$schema
),
$self
->_validate_type_array_items(
$_
[1],
$path
,
$schema
),
);
}
sub
_validate_type_array_contains {
my
(
$self
,
$data
,
$path
,
$schema
) =
@_
;
return
unless
exists
$schema
->{contains};
my
(
@e
,
@errors
);
for
my
$i
(0 ..
@$data
- 1) {
my
@tmp
=
$self
->_validate(
$data
->[
$i
],
"$path/$i"
,
$schema
->{contains});
push
@e
, \
@tmp
if
@tmp
;
}
push
@errors
,
map
{
@$_
}
@e
if
@e
>=
@$data
;
push
@errors
, E
$path
, [
array
=>
'contains'
]
if
not
@$data
;
return
@errors
;
}
sub
_validate_type_object {
my
(
$self
,
$data
,
$path
,
$schema
) =
@_
;
return
E
$path
, [
object
=>
type
=> data_type
$data
]
if
ref
$data
ne
'HASH'
;
return
(
$self
->_validate_type_object_min_max(
$_
[1],
$path
,
$schema
),
$self
->_validate_type_object_names(
$_
[1],
$path
,
$schema
),
$self
->_validate_type_object_properties(
$_
[1],
$path
,
$schema
),
$self
->_validate_type_object_dependencies(
$_
[1],
$path
,
$schema
),
);
}
sub
_validate_type_object_names {
my
(
$self
,
$data
,
$path
,
$schema
) =
@_
;
return
unless
exists
$schema
->{propertyNames};
my
@errors
;
for
my
$name
(
keys
%$data
) {
next
unless
my
@e
=
$self
->_validate(
$name
,
$path
,
$schema
->{propertyNames});
push
@errors
, prefix_errors
propertyName
=>
map
[
$name
,
$_
],
@e
;
}
return
@errors
;
}
1;