javonet-ruby-sdk 2.5.9 → 2.5.10

data/lib/javonet-ruby-sdk/Binaries/Perl/Windows/X64/deps/lib/perl5/Safe/Isa.pm

@@ -0,0 +1,213 @@
+package Safe::Isa;
+
+use strict;
+use warnings FATAL => 'all';
+use Scalar::Util ();
+use Exporter 5.57 qw(import);
+
+our $VERSION = '1.000010';
+
+our @EXPORT = qw($_call_if_object $_isa $_can $_does $_DOES $_call_if_can);
+
+our $_call_if_object = sub {
+  my ($obj, $method) = (shift, shift);
+  # This is intentionally a truth test, not a defined test, otherwise
+  # we gratuitously break modules like Scalar::Defer, which would be
+  # un-perlish.
+  return unless Scalar::Util::blessed($obj);
+  return $obj->$method(@_);
+};
+
+our ($_isa, $_can) = map {
+  my $method = $_;
+  sub { my $obj = shift; $obj->$_call_if_object($method => @_) }
+} qw(isa can);
+
+our $_call_if_can = sub {
+  my ($obj, $method) = (shift, shift);
+  return unless $obj->$_call_if_object(can => $method);
+  return $obj->$method(@_);
+};
+
+our $_does = sub {
+  my $obj = shift;
+  $obj->$_call_if_can(does => @_);
+};
+
+our $_DOES = sub {
+  my $obj = shift;
+  return unless Scalar::Util::blessed($obj);
+  return $obj->DOES(@_)
+    if $obj->can('DOES');
+  return $obj->isa(@_);
+};
+
+1;
+__END__
+
+=pod
+
+=head1 NAME
+
+Safe::Isa - Call isa, can, does and DOES safely on things that may not be objects
+
+=head1 SYNOPSIS
+
+  use strict;
+  use warnings;
+  
+  { package Foo; sub new { bless({}, $_[0]) } }
+  { package Bar; our @ISA = qw(Foo); sub bar { 1 } }
+  
+  my $foo = Foo->new;
+  my $bar = Bar->new;
+  my $blam = [ 42 ];
+  
+  # basic isa usage -
+  
+  $foo->isa('Foo');  # true
+  $bar->isa('Foo');  # true
+  $blam->isa('Foo'); # BOOM
+  
+  $foo->can('bar');  # false
+  $bar->can('bar');  # true
+  $blam->can('bar'); # BOOM
+  
+  # Safe::Isa usage -
+  
+  use Safe::Isa;
+  
+  $foo->$_isa('Foo');  # true
+  $bar->$_isa('Foo');  # true
+  $blam->$_isa('Foo'); # false, no boom today
+  
+  $foo->$_can('bar');  # false
+  $bar->$_can('bar');  # true
+  $blam->$_can('bar'); # false, no boom today
+
+Similarly:
+
+  $maybe_an_object->$_does('RoleName'); # true or false, no boom today
+  $maybe_an_object->$_DOES('RoleName'); # true or false, no boom today
+
+And just in case we missed a method or two:
+
+  $maybe_an_object->$_call_if_object(name => @args);
+  $maybe_an_object->$_call_if_can(name => @args);
+
+Or to re-use a previous example for purposes of explication:
+
+  $foo->$_call_if_object(isa => 'Foo');  # true
+  $bar->$_call_if_object(isa => 'Foo');  # true
+  $blam->$_call_if_object(isa => 'Foo'); # false, no boom today
+
+=head1 DESCRIPTION
+
+How many times have you found yourself writing:
+
+  if ($obj->isa('Something')) {
+
+and then shortly afterwards cursing and changing it to:
+
+  if (Scalar::Util::blessed($obj) and $obj->isa('Something')) {
+
+Right. That's why this module exists.
+
+Since perl allows us to provide a subroutine reference or a method name to
+the -> operator when used as a method call, and a subroutine doesn't require
+the invocant to actually be an object, we can create safe versions of isa,
+can and friends by using a subroutine reference that only tries to call the
+method if it's used on an object. So:
+
+  my $isa_Foo = $maybe_an_object->$_call_if_object(isa => 'Foo');
+
+is equivalent to
+
+  my $isa_Foo = do {
+    if (Scalar::Util::blessed($maybe_an_object)) {
+      $maybe_an_object->isa('Foo');
+    } else {
+      undef;
+    }
+  };
+
+Note that we don't handle trying class names, because many things are valid
+class names that you might not want to treat as one (like say "Matt") - the
+C<is_module_name> function from L<Module::Runtime> is a good way to check for
+something you might be able to call methods on if you want to do that.
+
+We are careful to make sure that scalar/list context is preserved for the
+method that is eventually called.
+
+=head1 EXPORTS
+
+=head2 $_isa
+
+  $maybe_an_object->$_isa('Foo');
+
+If called on an object, calls C<isa> on it and returns the result, otherwise
+returns nothing.
+
+=head2 $_can
+
+  $maybe_an_object->$_can('Foo');
+
+If called on an object, calls C<can> on it and returns the result, otherwise
+returns nothing.
+
+=head2 $_does
+
+  $maybe_an_object->$_does('Foo');
+
+If called on an object, calls C<does> on it and returns the result, otherwise
+returns nothing. If the C<does> method does not exist, returns nothing rather
+than failing.
+
+=head2 $_DOES
+
+  $maybe_an_object->$_DOES('Foo');
+
+If called on an object, calls C<DOES> on it and returns the result, otherwise
+returns nothing. On perl versions prior to 5.10.0, the built in core C<DOES>
+method doesn't exist. If the method doesn't exist, this will fall back to
+calling C<isa> just like the core C<DOES> method.
+
+=head2 $_call_if_object
+
+  $maybe_an_object->$_call_if_object(method_name => @args);
+
+If called on an object, calls C<method_name> on it and returns the result,
+otherwise returns nothing.
+
+=head2 $_call_if_can
+
+  $maybe_an_object->$_call_if_can(name => @args);
+
+If called on an object, calls C<can> on it; if that returns true, then
+calls C<method_name> on it and returns the result; if any condition is false
+returns nothing.
+
+=head1 SEE ALSO
+
+I gave a lightning talk on this module (and L<curry> and L<Import::Into>) at
+L<YAPC::NA 2013|https://www.youtube.com/watch?v=wFXWV2yY7gE&t=46m05s>.
+
+=head1 AUTHOR
+
+mst - Matt S. Trout (cpan:MSTROUT) <mst@shadowcat.co.uk>
+
+=head1 CONTRIBUTORS
+
+None yet. Well volunteered? :)
+
+=head1 COPYRIGHT
+
+Copyright (c) 2012 the Safe::Isa L</AUTHOR> and L</CONTRIBUTORS>
+as listed above.
+
+=head1 LICENSE
+
+This library is free software and may be distributed under the same terms
+as perl itself.
+
+=cut

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

@@ -0,0 +1,273 @@
+use strict;
+use warnings;
+package YAML::PP::Common;
+
+our $VERSION = 'v0.38.0'; # VERSION
+
+use base 'Exporter';
+
+my @p = qw/
+    PRESERVE_ALL PRESERVE_ORDER PRESERVE_SCALAR_STYLE PRESERVE_FLOW_STYLE
+    PRESERVE_ALIAS
+/;
+my @s = qw/
+    YAML_ANY_SCALAR_STYLE YAML_PLAIN_SCALAR_STYLE
+    YAML_SINGLE_QUOTED_SCALAR_STYLE YAML_DOUBLE_QUOTED_SCALAR_STYLE
+    YAML_LITERAL_SCALAR_STYLE YAML_FOLDED_SCALAR_STYLE
+    YAML_QUOTED_SCALAR_STYLE
+
+    YAML_ANY_SEQUENCE_STYLE
+    YAML_BLOCK_SEQUENCE_STYLE YAML_FLOW_SEQUENCE_STYLE
+
+    YAML_ANY_MAPPING_STYLE
+    YAML_BLOCK_MAPPING_STYLE YAML_FLOW_MAPPING_STYLE
+/;
+our @EXPORT_OK = (@s, @p);
+
+our %EXPORT_TAGS = (
+    PRESERVE => [@p],
+    STYLES => [@s],
+);
+
+use constant {
+    YAML_ANY_SCALAR_STYLE           => 0,
+    YAML_PLAIN_SCALAR_STYLE         => 1,
+    YAML_SINGLE_QUOTED_SCALAR_STYLE => 2,
+    YAML_DOUBLE_QUOTED_SCALAR_STYLE => 3,
+    YAML_LITERAL_SCALAR_STYLE       => 4,
+    YAML_FOLDED_SCALAR_STYLE        => 5,
+    YAML_QUOTED_SCALAR_STYLE        => 'Q', # deprecated
+
+    YAML_ANY_SEQUENCE_STYLE   => 0,
+    YAML_BLOCK_SEQUENCE_STYLE => 1,
+    YAML_FLOW_SEQUENCE_STYLE  => 2,
+
+    YAML_ANY_MAPPING_STYLE   => 0,
+    YAML_BLOCK_MAPPING_STYLE => 1,
+    YAML_FLOW_MAPPING_STYLE  => 2,
+
+    PRESERVE_ORDER        => 2,
+    PRESERVE_SCALAR_STYLE => 4,
+    PRESERVE_FLOW_STYLE   => 8,
+    PRESERVE_ALIAS        => 16,
+
+    PRESERVE_ALL          => 31,
+};
+
+my %scalar_style_to_string = (
+    YAML_PLAIN_SCALAR_STYLE() => ':',
+    YAML_SINGLE_QUOTED_SCALAR_STYLE() => "'",
+    YAML_DOUBLE_QUOTED_SCALAR_STYLE() => '"',
+    YAML_LITERAL_SCALAR_STYLE() => '|',
+    YAML_FOLDED_SCALAR_STYLE() => '>',
+);
+
+
+sub event_to_test_suite {
+    my ($event, $args) = @_;
+    my $ev = $event->{name};
+        my $string;
+        my $content = $event->{value};
+
+        my $properties = '';
+        $properties .= " &$event->{anchor}" if defined $event->{anchor};
+        $properties .= " <$event->{tag}>" if defined $event->{tag};
+
+        if ($ev eq 'document_start_event') {
+            $string = "+DOC";
+            $string .= " ---" unless $event->{implicit};
+        }
+        elsif ($ev eq 'document_end_event') {
+            $string = "-DOC";
+            $string .= " ..." unless $event->{implicit};
+        }
+        elsif ($ev eq 'stream_start_event') {
+            $string = "+STR";
+        }
+        elsif ($ev eq 'stream_end_event') {
+            $string = "-STR";
+        }
+        elsif ($ev eq 'mapping_start_event') {
+            $string = "+MAP";
+            if ($event->{style} and $event->{style} eq YAML_FLOW_MAPPING_STYLE) {
+                $string .= ' {}' if $args->{flow};
+            }
+            $string .= $properties;
+            if (0) {
+                # doesn't match yaml-test-suite format
+            }
+        }
+        elsif ($ev eq 'sequence_start_event') {
+            $string = "+SEQ";
+            if ($event->{style} and $event->{style} eq YAML_FLOW_SEQUENCE_STYLE) {
+                $string .= ' []' if $args->{flow};
+            }
+            $string .= $properties;
+            if (0) {
+                # doesn't match yaml-test-suite format
+            }
+        }
+        elsif ($ev eq 'mapping_end_event') {
+            $string = "-MAP";
+        }
+        elsif ($ev eq 'sequence_end_event') {
+            $string = "-SEQ";
+        }
+        elsif ($ev eq 'scalar_event') {
+            $string = '=VAL';
+            $string .= $properties;
+
+            $content =~ s/\\/\\\\/g;
+            $content =~ s/\t/\\t/g;
+            $content =~ s/\r/\\r/g;
+            $content =~ s/\n/\\n/g;
+            $content =~ s/[\b]/\\b/g;
+
+            $string .= ' '
+                . $scalar_style_to_string{ $event->{style} }
+                . $content;
+        }
+        elsif ($ev eq 'alias_event') {
+            $string = "=ALI *$content";
+        }
+        return $string;
+}
+
+sub test_suite_to_event {
+    my ($str) = @_;
+    my $event = {};
+    if ($str =~ s/^\+STR//) {
+        $event->{name} = 'stream_start_event';
+    }
+    elsif ($str =~ s/^\-STR//) {
+        $event->{name} = 'stream_end_event';
+    }
+    elsif ($str =~ s/^\+DOC//) {
+        $event->{name} = 'document_start_event';
+        if ($str =~ s/^ ---//) {
+            $event->{implicit} = 0;
+        }
+        else {
+            $event->{implicit} = 1;
+        }
+    }
+    elsif ($str =~ s/^\-DOC//) {
+        $event->{name} = 'document_end_event';
+        if ($str =~ s/^ \.\.\.//) {
+            $event->{implicit} = 0;
+        }
+        else {
+            $event->{implicit} = 1;
+        }
+    }
+    elsif ($str =~ s/^\+SEQ//) {
+        $event->{name} = 'sequence_start_event';
+        if ($str =~ s/^ \&(\S+)//) {
+            $event->{anchor} = $1;
+        }
+        if ($str =~ s/^ <(\S+)>//) {
+            $event->{tag} = $1;
+        }
+    }
+    elsif ($str =~ s/^\-SEQ//) {
+        $event->{name} = 'sequence_end_event';
+    }
+    elsif ($str =~ s/^\+MAP//) {
+        $event->{name} = 'mapping_start_event';
+        if ($str =~ s/^ \&(\S+)//) {
+            $event->{anchor} = $1;
+        }
+        if ($str =~ s/^ <(\S+)>//) {
+            $event->{tag} = $1;
+        }
+    }
+    elsif ($str =~ s/^\-MAP//) {
+        $event->{name} = 'mapping_end_event';
+    }
+    elsif ($str =~ s/^=VAL//) {
+        $event->{name} = 'scalar_event';
+        if ($str =~ s/^ <(\S+)>//) {
+            $event->{tag} = $1;
+        }
+        if ($str =~ s/^ [:'">|]//) {
+            $event->{style} = $1;
+        }
+        if ($str =~ s/^(.*)//) {
+            $event->{value} = $1;
+        }
+    }
+    elsif ($str =~ s/^=ALI//) {
+        $event->{name} = 'alias_event';
+        if ($str =~ s/^ \*(.*)//) {
+            $event->{value} = $1;
+        }
+    }
+    else {
+        die "Could not parse event '$str'";
+    }
+    return $event;
+}
+
+
+1;
+
+__END__
+
+=pod
+
+=encoding utf-8
+
+=head1 NAME
+
+YAML::PP::Common - Constants and common functions
+
+=head1 SYNOPSIS
+
+    use YAML::PP::Common ':STYLES';
+    # or
+    use YAML::PP::Common qw/
+        YAML_ANY_SCALAR_STYLE YAML_PLAIN_SCALAR_STYLE
+        YAML_SINGLE_QUOTED_SCALAR_STYLE YAML_DOUBLE_QUOTED_SCALAR_STYLE
+        YAML_LITERAL_SCALAR_STYLE YAML_FOLDED_SCALAR_STYLE
+        YAML_QUOTED_SCALAR_STYLE
+
+        YAML_ANY_SEQUENCE_STYLE
+        YAML_BLOCK_SEQUENCE_STYLE YAML_FLOW_SEQUENCE_STYLE
+
+        YAML_ANY_MAPPING_STYLE
+        YAML_BLOCK_MAPPING_STYLE YAML_FLOW_MAPPING_STYLE
+    /;
+
+    use YAML::PP::Common ':PRESERVE';
+    # or
+    use YAML::PP::Common qw/
+        PRESERVE_ALL PRESERVE_ORDER PRESERVE_SCALAR_STYLE PRESERVE_FLOW_STYLE
+        PRESERVE_ALIAS
+    /:
+
+=head1 DESCRIPTION
+
+This module provides common constants and functions for modules working with
+YAML::PP events.
+
+=head1 FUNCTIONS
+
+=over
+
+=item event_to_test_suite
+
+    my $string = YAML::PP::Common::event_to_test_suite($event_prom_parser);
+
+For examples of the returned format look into this distributions's directory
+C<yaml-test-suite> which is a copy of
+L<https://github.com/yaml/yaml-test-suite>.
+
+=item test_suite_to_event
+
+    my $event = YAML::PP::Common::test_suite_to_event($str);
+
+Turns an event string in test suite format into an event hashref. Not complete
+yet.
+
+=back
+