File Coverage

blib/lib/JSON/Schema/Modern/Vocabulary/OpenAPI_3_0.pm

Criterion	Covered	Total	%
statement	65	66	98.4
branch	4	6	66.6
condition	12	33	36.3
subroutine	21	22	95.4
pod	0	2	0.0
total	102	129	79.0

use strictures 2;
package JSON::Schema::Modern::Vocabulary::OpenAPI_3_0;
# vim: set ts=8 sts=2 sw=2 tw=100 et :
# ABSTRACT: Implementation of the JSON Schema OpenAPI 3.0 pseudo-vocabulary

our $VERSION = '0.139';

use 5.020;
use utf8;
use Moo;
use strictures 2;
use stable 0.031 'postderef';
use experimental 'signatures';
no autovivification warn => qw(fetch store exists delete);
use if "$]" >= 5.022, experimental => 're_strict';
no if "$]" >= 5.031009, feature => 'indirect';
no if "$]" >= 5.033001, feature => 'multidimensional';
no if "$]" >= 5.033006, feature => 'bareword_filehandles';
no if "$]" >= 5.041009, feature => 'smartmatch';
no feature 'switch';
use Scalar::Util 'looks_like_number';
use JSON::Schema::Modern::Utilities qw(get_type E);
use namespace::clean;

with 'JSON::Schema::Modern::Vocabulary';

sub vocabulary {}

my $vocabulary_mapping = {
  Core => [ '$ref' ],
  Validation => [ qw(
    type
    enum
    multipleOf
    maximum
    exclusiveMaximum
    minimum
    exclusiveMinimum
    maxLength
    minLength
    pattern
    maxItems
    minItems
    uniqueItems
    maxProperties
    minProperties
    required
  ) ],
  Applicator => [ qw(
    allOf
    anyOf
    oneOf
    not
    items
    properties
    additionalProperties
  ) ],
  Format => [ 'format' ],
  MetaData => [ qw(
    title
    description
    default
    deprecated
    readOnly
    writeOnly
    example
  ) ],
  # unique to OAS; all of these have null implementations
  Other => [ qw(
    nullable
    discriminator
    externalDocs
  ) ],
};

sub keywords {
  # most of these can be directly mapped to JSON Schema vocabulary keywords (3.0.4 §4.7.24.1).
  map @$_, $vocabulary_mapping->@{qw(Core Validation Applicator Format MetaData Other)};
}


# v3.0.4 §4.4: "Data types in the OAS are based on the non-null types supported by the JSON Schema
# Validation Specification Draft Wright-00: “boolean”, “object”, “array”, “number”, “string”, or
# “integer”. See nullable for an alternative solution to “null” as a type."
# v3.0.4 §4.7.24.1: ""items" MUST be present if type is "array"."
# "["type"] Value MUST be a string. Multiple types via an array are not supported."

sub _eval_keyword_type ($class, $data, $schema, $state) {
  return 1 if not defined $data and $schema->{nullable};

  my $type = get_type($data, { legacy_ints => 1 });
  my $want = $schema->{type};

  return 1 if
    $type eq $want or ($want eq 'number' and $type eq 'integer')
      or ($type eq 'string' and $state->{stringy_numbers} and looks_like_number($data)
          and ($want eq 'number' or ($want eq 'integer' and $data == int($data))))
      or ($want eq 'boolean' and $state->{scalarref_booleans} and $type eq 'reference to SCALAR');

  return E($state, 'got %s, not %s%s', $type, $want, $schema->{nullable} ? ' or null' : '');
}

foreach my $vocabulary (keys %$vocabulary_mapping) {
  foreach my $keyword ($vocabulary_mapping->{$vocabulary}->@*) {

    # There is no need to rigorously traverse schemas in v3.0 OpenAPI documents, as there are no
    # embedded identifiers to find ("id" is not a valid keyword).
    # The document validation pass on the document that we already do is sufficient to check the
    # schema keywords' syntax, and this saves us from having to implement custom methods for every
    # keyword that uses a subset of normal draft4 syntax (see v3.0.4 §4.7.24.1).

    my $k = $keyword =~ s/^\$//r;

    no strict 'refs';
    *{__PACKAGE__.'::_traverse_keyword_'.$k} = sub { 1 };

    next if $keyword eq 'type';

    # these keywords are no-ops
    next if $vocabulary eq 'MetaData' or $vocabulary eq 'Other';

    my $name = '_eval_keyword_'.$k;
    *{__PACKAGE__.'::'.$name} = *{'JSON::Schema::Modern::Vocabulary::'.$vocabulary.'::'.$name};
  }
}

1;

__END__