javonet-ruby-sdk 2.5.9 → 2.5.11

data/lib/javonet-ruby-sdk/Binaries/Perl/Linux/X64/deps/lib/perl5/YAML/PP/Schema/JSON.pm

@@ -0,0 +1,259 @@
+use strict;
+use warnings;
+package YAML::PP::Schema::JSON;
+
+our $VERSION = 'v0.38.1'; # VERSION
+
+use base 'Exporter';
+our @EXPORT_OK = qw/
+    represent_int represent_float represent_literal represent_bool
+    represent_undef
+/;
+
+use B;
+use Carp qw/ croak /;
+
+use YAML::PP::Common qw/ YAML_PLAIN_SCALAR_STYLE YAML_SINGLE_QUOTED_SCALAR_STYLE /;
+
+my $RE_INT = qr{^(-?(?:0|[1-9][0-9]*))$};
+my $RE_FLOAT = qr{^(-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][+-]?[0-9]+)?)$};
+
+sub _to_int { 0 + $_[2]->[0] }
+
+# DaTa++ && shmem++
+sub _to_float { unpack F => pack F => $_[2]->[0] }
+
+sub register {
+    my ($self, %args) = @_;
+    my $schema = $args{schema};
+    my $options = $args{options};
+    my $empty_null = 0;
+    for my $opt (@$options) {
+        if ($opt eq 'empty=str') {
+        }
+        elsif ($opt eq 'empty=null') {
+            $empty_null = 1;
+        }
+        else {
+            croak "Invalid option for JSON Schema: '$opt'";
+        }
+    }
+
+    $schema->add_resolver(
+        tag => 'tag:yaml.org,2002:null',
+        match => [ equals => null => undef ],
+    );
+    if ($empty_null) {
+        $schema->add_resolver(
+            tag => 'tag:yaml.org,2002:null',
+            match => [ equals => '' => undef ],
+            implicit => 1,
+        );
+    }
+    else {
+        $schema->add_resolver(
+            tag => 'tag:yaml.org,2002:str',
+            match => [ equals => '' => '' ],
+            implicit => 1,
+        );
+    }
+    $schema->add_resolver(
+        tag => 'tag:yaml.org,2002:bool',
+        match => [ equals => true => $schema->true ],
+    );
+    $schema->add_resolver(
+        tag => 'tag:yaml.org,2002:bool',
+        match => [ equals => false => $schema->false ],
+    );
+    $schema->add_resolver(
+        tag => 'tag:yaml.org,2002:int',
+        match => [ regex => $RE_INT => \&_to_int ],
+    );
+    $schema->add_resolver(
+        tag => 'tag:yaml.org,2002:float',
+        match => [ regex => $RE_FLOAT => \&_to_float ],
+    );
+    $schema->add_resolver(
+        tag => 'tag:yaml.org,2002:str',
+        match => [ all => sub { $_[1]->{value} } ],
+    );
+
+    $schema->add_representer(
+        undefined => \&represent_undef,
+    );
+
+    my $int_flags = B::SVp_IOK;
+    my $float_flags = B::SVp_NOK;
+    $schema->add_representer(
+        flags => $int_flags,
+        code => \&represent_int,
+    );
+    my %special = ( (0+'nan').'' => '.nan', (0+'inf').'' => '.inf', (0-'inf').'' => '-.inf' );
+    $schema->add_representer(
+        flags => $float_flags,
+        code => \&represent_float,
+    );
+    $schema->add_representer(
+        equals => $_,
+        code => \&represent_literal,
+    ) for ("", qw/ true false null /);
+    $schema->add_representer(
+        regex => qr{$RE_INT|$RE_FLOAT},
+        code => \&represent_literal,
+    );
+
+    if ($schema->bool_class) {
+        for my $class (@{ $schema->bool_class }) {
+            if ($class eq 'perl') {
+                $schema->add_representer(
+                    bool => 1,
+                    code => \&represent_bool,
+                );
+                next;
+            }
+            $schema->add_representer(
+                class_equals => $class,
+                code => \&represent_bool,
+            );
+        }
+    }
+
+    return;
+}
+
+sub represent_undef {
+    my ($rep, $node) = @_;
+    $node->{style} = YAML_PLAIN_SCALAR_STYLE;
+    $node->{data} = 'null';
+    return 1;
+}
+
+sub represent_literal {
+    my ($rep, $node) = @_;
+    $node->{style} ||= YAML_SINGLE_QUOTED_SCALAR_STYLE;
+    $node->{data} = "$node->{value}";
+    return 1;
+}
+
+
+sub represent_int {
+    my ($rep, $node) = @_;
+    if (int($node->{value}) ne $node->{value}) {
+        return 0;
+    }
+    $node->{style} = YAML_PLAIN_SCALAR_STYLE;
+    $node->{data} = "$node->{value}";
+    return 1;
+}
+
+my %special = (
+    (0+'nan').'' => '.nan',
+    (0+'inf').'' => '.inf',
+    (0-'inf').'' => '-.inf'
+);
+sub represent_float {
+    my ($rep, $node) = @_;
+    if (exists $special{ $node->{value} }) {
+        $node->{style} = YAML_PLAIN_SCALAR_STYLE;
+        $node->{data} = $special{ $node->{value} };
+        return 1;
+    }
+    if (0.0 + $node->{value} ne $node->{value}) {
+        return 0;
+    }
+    if (int($node->{value}) eq $node->{value} and not $node->{value} =~ m/\./) {
+        $node->{value} .= '.0';
+    }
+    $node->{style} = YAML_PLAIN_SCALAR_STYLE;
+    $node->{data} = "$node->{value}";
+    return 1;
+}
+
+sub represent_bool {
+    my ($rep, $node) = @_;
+    my $string = $node->{value} ? 'true' : 'false';
+    $node->{style} = YAML_PLAIN_SCALAR_STYLE;
+    @{ $node->{items} } = $string;
+    $node->{data} = $string;
+    return 1;
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding utf-8
+
+=head1 NAME
+
+YAML::PP::Schema::JSON - YAML 1.2 JSON Schema
+
+=head1 SYNOPSIS
+
+    my $yp = YAML::PP->new( schema => ['JSON'] );
+    my $yp = YAML::PP->new( schema => [qw/ JSON empty=str /] );
+    my $yp = YAML::PP->new( schema => [qw/ JSON empty=null /] );
+
+=head1 DESCRIPTION
+
+With this schema, the resolution of plain values will work like in JSON.
+Everything that matches a special value will be loaded as such, other plain
+scalars will be loaded as strings.
+
+Note that this is different from the official YAML 1.2 JSON Schema, where all
+strings have to be quoted.
+
+Here you can see all Schemas and examples implemented by YAML::PP:
+L<https://perlpunk.github.io/YAML-PP-p5/schemas.html>
+
+Official Schema: L<https://yaml.org/spec/1.2/spec.html#id2803231>
+
+=head1 CONFIGURATION
+
+The official YAML 1.2 JSON Schema wants all strings to be quoted.
+YAML::PP currently does not require that (it might do this optionally in
+the future).
+
+That means, there are no empty nodes allowed in the official schema. Example:
+
+    ---
+    key:
+
+The default behaviour of YAML::PP::Schema::JSON is to return an empty string,
+so it would be equivalent to:
+
+    ---
+    key: ''
+
+You can configure it to resolve this as C<undef>:
+
+    my $yp = YAML::PP->new( schema => [qw/ JSON empty=null /] );
+
+This way it is equivalent to:
+
+    ---
+    key: null
+
+The default is:
+
+    my $yp = YAML::PP->new( schema => [qw/ JSON empty=str /] );
+
+=head1 METHODS
+
+=over
+
+=item register
+
+Called by YAML::PP::Schema
+
+=item represent_bool, represent_float, represent_int, represent_literal, represent_undef
+
+Functions to represent the several node types.
+
+    represent_bool($representer, $node);
+
+=back
+
+=cut

data/lib/javonet-ruby-sdk/Binaries/Perl/Linux/X64/deps/lib/perl5/YAML/PP/Schema/Merge.pm

@@ -0,0 +1,109 @@
+use strict;
+use warnings;
+package YAML::PP::Schema::Merge;
+
+our $VERSION = 'v0.38.1'; # VERSION
+
+use YAML::PP::Type::MergeKey;
+
+sub register {
+    my ($self, %args) = @_;
+    my $schema = $args{schema};
+
+    $schema->add_resolver(
+        tag => 'tag:yaml.org,2002:merge',
+        match => [ equals => '<<' => YAML::PP::Type::MergeKey->new ],
+    );
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding utf-8
+
+=head1 NAME
+
+YAML::PP::Schema::Merge - Enabling YAML merge keys for mappings
+
+=head1 SYNOPSIS
+
+    use YAML::PP;
+    my $yp = YAML::PP->new( schema => [qw/ + Merge /] );
+
+    my $yaml = <<'EOM';
+    ---
+    - &CENTER { x: 1, y: 2 }
+    - &LEFT { x: 0, y: 2 }
+    - &BIG { r: 10 }
+    - &SMALL { r: 1 }
+
+    # All the following maps are equal:
+
+    - # Explicit keys
+      x: 1
+      y: 2
+      r: 10
+      label: center/big
+
+    - # Merge one map
+      << : *CENTER
+      r: 10
+      label: center/big
+
+    - # Merge multiple maps
+      << : [ *CENTER, *BIG ]
+      label: center/big
+
+    - # Override
+      << : [ *BIG, *LEFT, *SMALL ]
+      x: 1
+      label: center/big
+    EOM
+    my $data = $yp->load_string($yaml);
+    # $data->[4] == $data->[5] == $data->[6] == $data->[7]
+
+=head1 DESCRIPTION
+
+See L<https://yaml.org/type/merge.html> for the specification.
+
+Quote:
+
+"Specify one or more mappings to be merged with the current one.
+
+The C<< << >> merge key is used to indicate that all the keys of one or more
+specified maps should be inserted into the current map. If the value associated
+with the key is a single mapping node, each of its key/value pairs is inserted
+into the current mapping, unless the key already exists in it. If the value
+associated with the merge key is a sequence, then this sequence is expected to
+contain mapping nodes and each of these nodes is merged in turn according to its
+order in the sequence. Keys in mapping nodes earlier in the sequence override
+keys specified in later mapping nodes."
+
+The implementation of this in a generic way is not trivial, because we also
+have to handle duplicate keys, and YAML::PP allows you to write your own
+handler for processing mappings.
+
+So the inner API of that is not stable at this point.
+
+Note that if you enable this schema, a plain scalar `<<` will be seen as
+special anywhere in your document, so if you want a literal `<<`, you have
+to put it in quotes.
+
+Note that the performed merge is not a "deep merge". Only top-level keys are
+merged.
+
+=head1 METHODS
+
+=over
+
+=item register
+
+Called by YAML::PP::Schema
+
+=back
+
+=cut
+