javonet-ruby-sdk 2.5.8 → 2.5.10

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

@@ -0,0 +1,83 @@
+use strict;
+use warnings;
+package YAML::PP::Perl;
+
+our $VERSION = 'v0.38.0'; # VERSION
+
+use base 'Exporter';
+use base 'YAML::PP';
+our @EXPORT_OK = qw/ Load Dump LoadFile DumpFile /;
+
+use YAML::PP;
+use YAML::PP::Schema::Perl;
+
+sub new {
+    my ($class, %args) = @_;
+    $args{schema} ||= [qw/ Core Perl /];
+    $class->SUPER::new(%args);
+}
+
+sub Load {
+    my ($yaml) = @_;
+    __PACKAGE__->new->load_string($yaml);
+}
+
+sub LoadFile {
+    my ($file) = @_;
+    __PACKAGE__->new->load_file($file);
+}
+
+sub Dump {
+    my (@data) = @_;
+    __PACKAGE__->new->dump_string(@data);
+}
+
+sub DumpFile {
+    my ($file, @data) = @_;
+    __PACKAGE__->new->dump_file($file, @data);
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding utf-8
+
+=head1 NAME
+
+YAML::PP::Perl - Convenience module for loading and dumping Perl objects
+
+=head1 SYNOPSIS
+
+    use YAML::PP::Perl;
+    my @docs = YAML::PP::Perl->new->load_string($yaml);
+    my @docs = YAML::PP::Perl::Load($yaml);
+
+    # same as
+    use YAML::PP;
+    my $yp = YAML::PP->new( schema => [qw/ Core Perl /] );
+    my @docs = $yp->load_string($yaml);
+
+=head1 DESCRIPTION
+
+This is just for convenience. It will create a YAML::PP object using the
+default schema (C<Core>) and the L<YAML::PP::Schema::Perl> schema.
+
+See L<YAML::PP::Schema::Perl> for documentation.
+
+=head1 METHODS
+
+=over
+
+=item Load, Dump, LoadFile, DumpFile
+
+These work like the functions in L<YAML::PP>, just adding the C<Perl> schema.
+
+=item new
+
+Constructor, works like in L<YAML::PP>, just adds the C<Perl> schema to the
+list of arguments.
+
+=back

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

@@ -0,0 +1,78 @@
+# ABSTRACT: Reader class for YAML::PP representing input data
+use strict;
+use warnings;
+package YAML::PP::Reader;
+
+our $VERSION = 'v0.38.0'; # VERSION
+
+sub input { return $_[0]->{input} }
+sub set_input { $_[0]->{input} = $_[1] }
+
+sub new {
+    my ($class, %args) = @_;
+    my $input = delete $args{input};
+    return bless {
+        input => $input,
+    }, $class;
+}
+
+sub read {
+    my ($self) = @_;
+    my $pos = pos $self->{input} || 0;
+    my $yaml = substr($self->{input}, $pos);
+    $self->{input} = '';
+    return $yaml;
+}
+
+sub readline {
+    my ($self) = @_;
+    unless (length $self->{input}) {
+        return;
+    }
+    if ( $self->{input} =~ m/\G([^\r\n]*(?:\n|\r\n|\r|\z))/g ) {
+        my $line = $1;
+        unless (length $line) {
+            $self->{input} = '';
+            return;
+        }
+        return $line;
+    }
+    return;
+}
+
+package YAML::PP::Reader::File;
+
+use Scalar::Util qw/ openhandle /;
+
+our @ISA = qw/ YAML::PP::Reader /;
+
+use Carp qw/ croak /;
+
+sub open_handle {
+    if (openhandle( $_[0]->{input} )) {
+        return $_[0]->{input};
+    }
+    open my $fh, '<:encoding(UTF-8)', $_[0]->{input}
+        or croak "Could not open '$_[0]->{input}' for reading: $!";
+    return $fh;
+}
+
+sub read {
+    my $fh = $_[0]->{filehandle} ||= $_[0]->open_handle;
+    if (wantarray) {
+        my @yaml = <$fh>;
+        return @yaml;
+    }
+    else {
+        local $/;
+        my $yaml = <$fh>;
+        return $yaml;
+    }
+}
+
+sub readline {
+    my $fh = $_[0]->{filehandle} ||= $_[0]->open_handle;
+    return scalar <$fh>;
+}
+
+1;

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

@@ -0,0 +1,155 @@
+# ABSTRACT: YAML::PP Rendering functions
+use strict;
+use warnings;
+package YAML::PP::Render;
+
+our $VERSION = 'v0.38.0'; # VERSION
+
+use constant TRACE => $ENV{YAML_PP_TRACE} ? 1 : 0;
+
+sub render_quoted {
+    my ($self, $style, $lines) = @_;
+
+    my $quoted = '';
+    my $addspace = 0;
+
+    for my $i (0 .. $#$lines) {
+        my $line = $lines->[ $i ];
+        my $value = $line->{value};
+        my $last = $i == $#$lines;
+        my $first = $i == 0;
+        if ($value eq '') {
+            if ($first) {
+                $addspace = 1;
+            }
+            elsif ($last) {
+                $quoted .= ' ' if $addspace;
+            }
+            else {
+                $addspace = 0;
+                $quoted .= "\n";
+            }
+            next;
+        }
+
+        $quoted .= ' ' if $addspace;
+        $addspace = 1;
+        if ($style eq '"') {
+            if ($line->{orig} =~ m/\\$/) {
+                $line->{value} =~ s/\\$//;
+                $value =~ s/\\$//;
+                $addspace = 0;
+            }
+        }
+        $quoted .= $value;
+    }
+    return $quoted;
+}
+
+sub render_block_scalar {
+    my ($self, $block_type, $chomp, $lines) = @_;
+
+    my ($folded, $keep, $trim);
+    if ($block_type eq '>') {
+        $folded = 1;
+    }
+    if ($chomp eq '+') {
+        $keep = 1;
+    }
+    elsif ($chomp eq '-') {
+        $trim = 1;
+    }
+
+    my $string = '';
+    if (not $keep) {
+        # remove trailing empty lines
+        while (@$lines) {
+            last if $lines->[-1] ne '';
+            pop @$lines;
+        }
+    }
+    if ($folded) {
+
+        my $prev = 'START';
+        my $trailing = '';
+        if ($keep) {
+            while (@$lines and $lines->[-1] eq '') {
+                pop @$lines;
+                $trailing .= "\n";
+            }
+        }
+        for my $i (0 .. $#$lines) {
+            my $line = $lines->[ $i ];
+
+            my $type = $line eq ''
+                ? 'EMPTY'
+                : $line =~ m/\A[ \t]/
+                    ? 'MORE'
+                    : 'CONTENT';
+
+            if ($prev eq 'MORE' and $type eq 'EMPTY') {
+                $type = 'MORE';
+            }
+            elsif ($prev eq 'CONTENT') {
+                if ($type ne 'CONTENT') {
+                    $string .= "\n";
+                }
+                elsif ($type eq 'CONTENT') {
+                    $string .= ' ';
+                }
+            }
+            elsif ($prev eq 'START' and $type eq 'EMPTY') {
+                $string .= "\n";
+                $type = 'START';
+            }
+            elsif ($prev eq 'EMPTY' and $type ne 'CONTENT') {
+                $string .= "\n";
+            }
+
+            $string .= $line;
+
+            if ($type eq 'MORE' and $i < $#$lines) {
+                $string .= "\n";
+            }
+
+            $prev = $type;
+        }
+        if ($keep) {
+            $string .= $trailing;
+        }
+        $string .= "\n" if @$lines and not $trim;
+    }
+    else {
+        for my $i (0 .. $#$lines) {
+            $string .= $lines->[ $i ];
+            $string .= "\n" if ($i != $#$lines or not $trim);
+        }
+    }
+    TRACE and warn __PACKAGE__.':'.__LINE__.$".Data::Dumper->Dump([\$string], ['string']);
+    return $string;
+}
+
+sub render_multi_val {
+    my ($self, $multi) = @_;
+    my $string = '';
+    my $start = 1;
+    for my $line (@$multi) {
+        if (not $start) {
+            if ($line eq '') {
+                $string .= "\n";
+                $start = 1;
+            }
+            else {
+                $string .= " $line";
+            }
+        }
+        else {
+            $string .= $line;
+            $start = 0;
+        }
+    }
+    return $string;
+}
+
+
+1;

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

@@ -0,0 +1,230 @@
+use strict;
+use warnings;
+package YAML::PP::Representer;
+
+our $VERSION = 'v0.38.0'; # VERSION
+
+use Scalar::Util qw/ reftype blessed refaddr /;
+
+use YAML::PP::Common qw/
+    YAML_PLAIN_SCALAR_STYLE YAML_SINGLE_QUOTED_SCALAR_STYLE
+    YAML_DOUBLE_QUOTED_SCALAR_STYLE
+    YAML_ANY_SCALAR_STYLE
+    YAML_LITERAL_SCALAR_STYLE YAML_FOLDED_SCALAR_STYLE
+    YAML_FLOW_SEQUENCE_STYLE YAML_FLOW_MAPPING_STYLE
+    YAML_BLOCK_MAPPING_STYLE YAML_BLOCK_SEQUENCE_STYLE
+    PRESERVE_ORDER PRESERVE_SCALAR_STYLE PRESERVE_FLOW_STYLE PRESERVE_ALIAS
+/;
+use B;
+
+sub new {
+    my ($class, %args) = @_;
+    my $preserve = delete $args{preserve} || 0;
+    if ($preserve == 1) {
+        $preserve = PRESERVE_ORDER | PRESERVE_SCALAR_STYLE | PRESERVE_FLOW_STYLE | PRESERVE_ALIAS;
+    }
+    my $self = bless {
+        schema => delete $args{schema},
+        preserve => $preserve,
+    }, $class;
+    if (keys %args) {
+        die "Unexpected arguments: " . join ', ', sort keys %args;
+    }
+    return $self;
+}
+
+sub clone {
+    my ($self) = @_;
+    my $clone = {
+        schema => $self->schema,
+        preserve => $self->{preserve},
+    };
+    return bless $clone, ref $self;
+}
+
+sub schema { return $_[0]->{schema} }
+sub preserve_order { return $_[0]->{preserve} & PRESERVE_ORDER }
+sub preserve_scalar_style { return $_[0]->{preserve} & PRESERVE_SCALAR_STYLE }
+sub preserve_flow_style { return $_[0]->{preserve} & PRESERVE_FLOW_STYLE }
+sub preserve_alias { return $_[0]->{preserve} & PRESERVE_ALIAS }
+
+sub represent_node {
+    my ($self, $node) = @_;
+
+    my $preserve_alias = $self->preserve_alias;
+    my $preserve_style = $self->preserve_scalar_style;
+    if ($preserve_style or $preserve_alias) {
+        if (ref $node->{value} eq 'YAML::PP::Preserve::Scalar') {
+            my $value = $node->{value}->value;
+            if ($preserve_style) {
+                $node->{style} = $node->{value}->style;
+            }
+#            $node->{tag} = $node->{value}->tag;
+            $node->{value} = $value;
+        }
+    }
+    $node->{reftype} = reftype($node->{value});
+    if (not $node->{reftype} and reftype(\$node->{value}) eq 'GLOB') {
+        $node->{reftype} = 'GLOB';
+    }
+
+    if ($node->{reftype}) {
+        $self->_represent_noderef($node);
+    }
+    else {
+        $self->_represent_node_nonref($node);
+    }
+    $node->{reftype} = (reftype $node->{data}) || '';
+
+    if ($node->{reftype} eq 'HASH' and my $tied = tied(%{ $node->{data} })) {
+        my $representers = $self->schema->representers;
+        $tied = ref $tied;
+        if (my $def = $representers->{tied_equals}->{ $tied }) {
+            my $code = $def->{code};
+            my $done = $code->($self, $node);
+        }
+    }
+
+    if ($node->{reftype} eq 'HASH') {
+        unless (defined $node->{items}) {
+            # by default we sort hash keys
+            my @keys;
+            if ($self->preserve_order) {
+                @keys = keys %{ $node->{data} };
+            }
+            else {
+                @keys = sort keys %{ $node->{data} };
+            }
+            for my $key (@keys) {
+                push @{ $node->{items} }, $key, $node->{data}->{ $key };
+            }
+        }
+        my %args;
+        if ($self->preserve_flow_style and reftype $node->{value} eq 'HASH') {
+            if (my $tied = tied %{ $node->{value} } ) {
+                $args{style} = $tied->{style};
+            }
+        }
+        return [ mapping => $node, %args ];
+    }
+    elsif ($node->{reftype} eq 'ARRAY') {
+        unless (defined $node->{items}) {
+            @{ $node->{items} } = @{ $node->{data} };
+        }
+        my %args;
+        if ($self->preserve_flow_style and reftype $node->{value} eq 'ARRAY') {
+            if (my $tied = tied @{ $node->{value} } ) {
+                $args{style} = $tied->{style};
+            }
+        }
+        return [ sequence => $node, %args ];
+    }
+    elsif ($node->{reftype}) {
+        die "Cannot handle reftype '$node->{reftype}' (you might want to enable YAML::PP::Schema::Perl)";
+    }
+    else {
+        unless (defined $node->{items}) {
+            $node->{items} = [$node->{data}];
+        }
+        return [ scalar => $node ];
+    }
+
+}
+
+my $bool_code = <<'EOM';
+sub {
+    my ($x) = @_;
+    use experimental qw/ builtin /;
+    builtin::is_bool($x);
+}
+EOM
+my $is_bool;
+
+sub _represent_node_nonref {
+    my ($self, $node) = @_;
+    my $representers = $self->schema->representers;
+
+    if (not defined $node->{value}) {
+        if (my $undef = $representers->{undef}) {
+            return 1 if $undef->($self, $node);
+        }
+        else {
+            $node->{style} = YAML_SINGLE_QUOTED_SCALAR_STYLE;
+            $node->{data} = '';
+            return 1;
+        }
+    }
+    if ($] >= 5.036000 and my $rep = $representers->{bool}) {
+        $is_bool ||= eval $bool_code;
+        if ($is_bool->($node->{value})) {
+            return $rep->{code}->($self, $node);
+        }
+    }
+    for my $rep (@{ $representers->{flags} }) {
+        my $check_flags = $rep->{flags};
+        my $flags = B::svref_2object(\$node->{value})->FLAGS;
+        if ($flags & $check_flags) {
+            return 1 if $rep->{code}->($self, $node);
+        }
+
+    }
+    if (my $rep = $representers->{equals}->{ $node->{value} }) {
+        return 1 if $rep->{code}->($self, $node);
+    }
+    for my $rep (@{ $representers->{regex} }) {
+        if ($node->{value} =~ $rep->{regex}) {
+            return 1 if $rep->{code}->($self, $node);
+        }
+    }
+    unless (defined $node->{data}) {
+        $node->{data} = $node->{value};
+    }
+    unless (defined $node->{style}) {
+        $node->{style} = YAML_ANY_SCALAR_STYLE;
+        $node->{style} = "";
+    }
+}
+
+sub _represent_noderef {
+    my ($self, $node) = @_;
+    my $representers = $self->schema->representers;
+
+    if (my $classname = blessed($node->{value})) {
+        if (my $def = $representers->{class_equals}->{ $classname }) {
+            my $code = $def->{code};
+            return 1 if $code->($self, $node);
+        }
+        for my $matches (@{ $representers->{class_matches} }) {
+            my ($re, $code) = @$matches;
+            if (ref $re and $classname =~ $re or $re) {
+                return 1 if $code->($self, $node);
+            }
+        }
+        for my $isa (@{ $representers->{class_isa} }) {
+            my ($class_name, $code) = @$isa;
+            if ($node->{ value }->isa($class_name)) {
+                return 1 if $code->($self, $node);
+            }
+        }
+    }
+    if ($node->{reftype} eq 'SCALAR' and my $scalarref = $representers->{scalarref}) {
+        my $code = $scalarref->{code};
+        return 1 if $code->($self, $node);
+    }
+    if ($node->{reftype} eq 'REF' and my $refref = $representers->{refref}) {
+        my $code = $refref->{code};
+        return 1 if $code->($self, $node);
+    }
+    if ($node->{reftype} eq 'CODE' and my $coderef = $representers->{coderef}) {
+        my $code = $coderef->{code};
+        return 1 if $code->($self, $node);
+    }
+    if ($node->{reftype} eq 'GLOB' and my $glob = $representers->{glob}) {
+        my $code = $glob->{code};
+        return 1 if $code->($self, $node);
+    }
+    $node->{data} = $node->{value};
+
+}
+
+1;

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

@@ -0,0 +1,102 @@
+use strict;
+use warnings;
+package YAML::PP::Schema::Binary;
+
+our $VERSION = 'v0.38.0'; # VERSION
+
+use MIME::Base64 qw/ decode_base64 encode_base64 /;
+use YAML::PP::Common qw/ YAML_ANY_SCALAR_STYLE /;
+
+sub register {
+    my ($self, %args) = @_;
+    my $schema = $args{schema};
+
+    $schema->add_resolver(
+        tag => 'tag:yaml.org,2002:binary',
+        match => [ all => sub {
+            my ($constructor, $event) = @_;
+            my $base64 = $event->{value};
+            my $binary = decode_base64($base64);
+            return $binary;
+        }],
+        implicit => 0,
+    );
+
+    $schema->add_representer(
+        regex => qr{.*},
+        code => sub {
+            my ($rep, $node) = @_;
+            my $binary = $node->{value};
+            unless ($binary =~ m/[\x{7F}-\x{10FFFF}]/) {
+                # ASCII
+                return;
+            }
+            if (utf8::is_utf8($binary)) {
+                # utf8
+                return;
+            }
+            # everything else must be base64 encoded
+            my $base64 = encode_base64($binary);
+            $node->{style} = YAML_ANY_SCALAR_STYLE;
+            $node->{data} = $base64;
+            $node->{tag} = "tag:yaml.org,2002:binary";
+            return 1;
+        },
+    );
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding utf-8
+
+=head1 NAME
+
+YAML::PP::Schema::Binary - Schema for loading and binary data
+
+=head1 SYNOPSIS
+
+    use YAML::PP;
+    my $yp = YAML::PP->new( schema => [qw/ + Binary /] );
+    # or
+
+    my ($binary, $same_binary) = $yp->load_string(<<'EOM');
+    --- !!binary "\
+      R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5\
+      OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+\
+      +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC\
+      AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs="
+    --- !!binary |
+      R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
+      OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+
+      +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
+      AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
+    # The binary value above is a tiny arrow encoded as a gif image.
+    EOM
+
+=head1 DESCRIPTION
+
+See <https://yaml.org/type/binary.html>
+
+By prepending a base64 encoded binary string with the C<!!binary> tag, it can
+be automatically decoded when loading.
+
+Note that the logic for dumping is probably broken, see
+L<https://github.com/perlpunk/YAML-PP-p5/issues/28>.
+
+Suggestions welcome.
+
+=head1 METHODS
+
+=over
+
+=item register
+
+Called by L<YAML::PP::Schema>
+
+=back
+
+=cut