javonet-ruby-sdk 2.4.9 → 2.4.11

data/lib/javonet-ruby-sdk/Binaries/Perl/MacOs/X64/deps/lib/perl5/Sub/Exporter/Util.pm

@@ -1,488 +0,0 @@
-use v5.12.0;
-use warnings;
-package Sub::Exporter::Util 0.991;
-# ABSTRACT: utilities to make Sub::Exporter easier
-
-use Data::OptList ();
-use Params::Util ();
-
-#pod =head1 DESCRIPTION
-#pod
-#pod This module provides a number of utility functions for performing common or
-#pod useful operations when setting up a Sub::Exporter configuration.  All of the
-#pod utilities may be exported, but none are by default.
-#pod
-#pod =head1 THE UTILITIES
-#pod
-#pod =head2 curry_method
-#pod
-#pod   exports => {
-#pod     some_method => curry_method,
-#pod   }
-#pod
-#pod This utility returns a generator which will produce an invocant-curried version
-#pod of a method.  In other words, it will export a method call with the exporting
-#pod class built in as the invocant.
-#pod
-#pod A module importing the code some the above example might do this:
-#pod
-#pod   use Some::Module qw(some_method);
-#pod
-#pod   my $x = some_method;
-#pod
-#pod This would be equivalent to:
-#pod
-#pod   use Some::Module;
-#pod
-#pod   my $x = Some::Module->some_method;
-#pod
-#pod If Some::Module is subclassed and the subclass's import method is called to
-#pod import C<some_method>, the subclass will be curried in as the invocant.
-#pod
-#pod If an argument is provided for C<curry_method> it is used as the name of the
-#pod curried method to export.  This means you could export a Widget constructor
-#pod like this:
-#pod
-#pod   exports => { widget => curry_method('new') }
-#pod
-#pod This utility may also be called as C<curry_class>, for backwards compatibility.
-#pod
-#pod =cut
-
-sub curry_method {
-  my $override_name = shift;
-  sub {
-    my ($class, $name) = @_;
-    $name = $override_name if defined $override_name;
-    sub { $class->$name(@_); };
-  }
-}
-
-BEGIN { *curry_class = \&curry_method; }
-
-#pod =head2 curry_chain
-#pod
-#pod C<curry_chain> behaves like C<L</curry_method>>, but is meant for generating
-#pod exports that will call several methods in succession.
-#pod
-#pod   exports => {
-#pod     reticulate => curry_chain(
-#pod       new => gather_data => analyze => [ detail => 100 ] => 'results'
-#pod     ),
-#pod   }
-#pod
-#pod If imported from Spliner, calling the C<reticulate> routine will be equivalent
-#pod to:
-#pod
-#pod   Spliner->new->gather_data->analyze(detail => 100)->results;
-#pod
-#pod If any method returns something on which methods may not be called, the routine
-#pod croaks.
-#pod
-#pod The arguments to C<curry_chain> form an optlist.  The names are methods to be
-#pod called and the arguments, if given, are arrayrefs to be dereferenced and passed
-#pod as arguments to those methods.  C<curry_chain> returns a generator like those
-#pod expected by Sub::Exporter.
-#pod
-#pod B<Achtung!> at present, there is no way to pass arguments from the generated
-#pod routine to the method calls.  This will probably be solved in future revisions
-#pod by allowing the opt list's values to be subroutines that will be called with
-#pod the generated routine's stack.
-#pod
-#pod =cut
-
-sub curry_chain {
-  # In the future, we can make \%arg an optional prepend, like the "special"
-  # args to the default Sub::Exporter-generated import routine.
-  my (@opt_list) = @_;
-
-  my $pairs = Data::OptList::mkopt(\@opt_list, 'args', 'ARRAY');
-
-  sub {
-    my ($class) = @_;
-
-    sub {
-      my $next = $class;
-
-      for my $i (0 .. $#$pairs) {
-        my $pair = $pairs->[ $i ];
-
-        unless (Params::Util::_INVOCANT($next)) { ## no critic Private
-          my $str = defined $next ? "'$next'" : 'undef';
-          Carp::croak("can't call $pair->[0] on non-invocant $str")
-        }
-
-        my ($method, $args) = @$pair;
-
-        if ($i == $#$pairs) {
-          return $next->$method($args ? @$args : ());
-        } else {
-          $next = $next->$method($args ? @$args : ());
-        }
-      }
-    };
-  }
-}
-
-# =head2 name_map
-#
-# This utility returns an list to be used in specify export generators.  For
-# example, the following:
-#
-#   exports => {
-#     name_map(
-#       '_?_gen'  => [ qw(fee fie) ],
-#       '_make_?' => [ qw(foo bar) ],
-#     ),
-#   }
-#
-# is equivalent to:
-#
-#   exports => {
-#     name_map(
-#       fee => \'_fee_gen',
-#       fie => \'_fie_gen',
-#       foo => \'_make_foo',
-#       bar => \'_make_bar',
-#     ),
-#   }
-#
-# This can save a lot of typing, when providing many exports with similarly-named
-# generators.
-#
-# =cut
-#
-# sub name_map {
-#   my (%groups) = @_;
-#
-#   my %map;
-#
-#   while (my ($template, $names) = each %groups) {
-#     for my $name (@$names) {
-#       (my $export = $template) =~ s/\?/$name/
-#         or Carp::croak 'no ? found in name_map template';
-#
-#       $map{ $name } = \$export;
-#     }
-#   }
-#
-#   return %map;
-# }
-
-#pod =head2 merge_col
-#pod
-#pod   exports => {
-#pod     merge_col(defaults => {
-#pod       twiddle => \'_twiddle_gen',
-#pod       tweak   => \&_tweak_gen,
-#pod     }),
-#pod   }
-#pod
-#pod This utility wraps the given generator in one that will merge the named
-#pod collection into its args before calling it.  This means that you can support a
-#pod "default" collector in multiple exports without writing the code each time.
-#pod
-#pod You can specify as many pairs of collection names and generators as you like.
-#pod
-#pod =cut
-
-sub merge_col {
-  my (%groups) = @_;
-
-  my %merged;
-
-  while (my ($default_name, $group) = each %groups) {
-    while (my ($export_name, $gen) = each %$group) {
-      $merged{$export_name} = sub {
-        my ($class, $name, $arg, $col) = @_;
-
-        my $merged_arg = exists $col->{$default_name}
-                       ? { %{ $col->{$default_name} }, %$arg }
-                       : $arg;
-
-        if (Params::Util::_CODELIKE($gen)) { ## no critic Private
-          $gen->($class, $name, $merged_arg, $col);
-        } else {
-          $class->$$gen($name, $merged_arg, $col);
-        }
-      }
-    }
-  }
-
-  return %merged;
-}
-
-#pod =head2 mixin_installer
-#pod
-#pod   use Sub::Exporter -setup => {
-#pod     installer => Sub::Exporter::Util::mixin_installer,
-#pod     exports   => [ qw(foo bar baz) ],
-#pod   };
-#pod
-#pod This utility returns an installer that will install into a superclass and
-#pod adjust the ISA importing class to include the newly generated superclass.
-#pod
-#pod If the target of importing is an object, the hierarchy is reversed: the new
-#pod class will be ISA the object's class, and the object will be reblessed.
-#pod
-#pod B<Prerequisites>: This utility requires that Package::Generator be installed.
-#pod
-#pod =cut
-
-sub __mixin_class_for {
-  my ($class, $mix_into) = @_;
-  require Package::Generator;
-  my $mixin_class = Package::Generator->new_package({
-    base => "$class\:\:__mixin__",
-  });
-
-  ## no critic (ProhibitNoStrict)
-  no strict 'refs';
-  if (ref $mix_into) {
-    unshift @{"$mixin_class" . "::ISA"}, ref $mix_into;
-  } else {
-    unshift @{"$mix_into" . "::ISA"}, $mixin_class;
-  }
-  return $mixin_class;
-}
-
-sub mixin_installer {
-  sub {
-    my ($arg, $to_export) = @_;
-
-    my $mixin_class = __mixin_class_for($arg->{class}, $arg->{into});
-    bless $arg->{into} => $mixin_class if ref $arg->{into};
-
-    Sub::Exporter::default_installer(
-      { %$arg, into => $mixin_class },
-      $to_export,
-    );
-  };
-}
-
-sub mixin_exporter {
-  Carp::cluck "mixin_exporter is deprecated; use mixin_installer instead; it behaves identically";
-  return mixin_installer;
-}
-
-#pod =head2 like
-#pod
-#pod It's a collector that adds imports for anything like given regex.
-#pod
-#pod If you provide this configuration:
-#pod
-#pod   exports    => [ qw(igrep imap islurp exhausted) ],
-#pod   collectors => { -like => Sub::Exporter::Util::like },
-#pod
-#pod A user may import from your module like this:
-#pod
-#pod   use Your::Iterator -like => qr/^i/; # imports igre, imap, islurp
-#pod
-#pod or
-#pod
-#pod   use Your::Iterator -like => [ qr/^i/ => { -prefix => 'your_' } ];
-#pod
-#pod The group-like prefix and suffix arguments are respected; other arguments are
-#pod passed on to the generators for matching exports.
-#pod
-#pod =cut
-
-sub like {
-  sub {
-    my ($value, $arg) = @_;
-    Carp::croak "no regex supplied to regex group generator" unless $value;
-
-    # Oh, qr//, how you bother me!  See the p5p thread from around now about
-    # fixing this problem... too bad it won't help me. -- rjbs, 2006-04-25
-    my @values = eval { $value->isa('Regexp') } ? ($value, undef)
-               :                                  @$value;
-
-    while (my ($re, $opt) = splice @values, 0, 2) {
-      Carp::croak "given pattern for regex group generater is not a Regexp"
-        unless eval { $re->isa('Regexp') };
-      my @exports  = keys %{ $arg->{config}->{exports} };
-      my @matching = grep { $_ =~ $re } @exports;
-
-      my %merge = $opt ? %$opt : ();
-      my $prefix = (delete $merge{-prefix}) || '';
-      my $suffix = (delete $merge{-suffix}) || '';
-
-      for my $name (@matching) {
-        my $as = $prefix . $name . $suffix;
-        push @{ $arg->{import_args} }, [ $name => { %merge, -as => $as } ];
-      }
-    }
-
-    1;
-  }
-}
-
-use Sub::Exporter -setup => {
-  exports => [ qw(
-    like
-    name_map
-    merge_col
-    curry_method curry_class
-    curry_chain
-    mixin_installer mixin_exporter
-  ) ]
-};
-
-1;
-
-__END__
-
-=pod
-
-=encoding UTF-8
-
-=head1 NAME
-
-Sub::Exporter::Util - utilities to make Sub::Exporter easier
-
-=head1 VERSION
-
-version 0.991
-
-=head1 DESCRIPTION
-
-This module provides a number of utility functions for performing common or
-useful operations when setting up a Sub::Exporter configuration.  All of the
-utilities may be exported, but none are by default.
-
-=head1 PERL VERSION
-
-This library should run on perls released even a long time ago.  It should
-work on any version of perl released in the last five years.
-
-Although it may work on older versions of perl, no guarantee is made that the
-minimum required version will not be increased.  The version may be increased
-for any reason, and there is no promise that patches will be accepted to
-lower the minimum required perl.
-
-=head1 THE UTILITIES
-
-=head2 curry_method
-
-  exports => {
-    some_method => curry_method,
-  }
-
-This utility returns a generator which will produce an invocant-curried version
-of a method.  In other words, it will export a method call with the exporting
-class built in as the invocant.
-
-A module importing the code some the above example might do this:
-
-  use Some::Module qw(some_method);
-
-  my $x = some_method;
-
-This would be equivalent to:
-
-  use Some::Module;
-
-  my $x = Some::Module->some_method;
-
-If Some::Module is subclassed and the subclass's import method is called to
-import C<some_method>, the subclass will be curried in as the invocant.
-
-If an argument is provided for C<curry_method> it is used as the name of the
-curried method to export.  This means you could export a Widget constructor
-like this:
-
-  exports => { widget => curry_method('new') }
-
-This utility may also be called as C<curry_class>, for backwards compatibility.
-
-=head2 curry_chain
-
-C<curry_chain> behaves like C<L</curry_method>>, but is meant for generating
-exports that will call several methods in succession.
-
-  exports => {
-    reticulate => curry_chain(
-      new => gather_data => analyze => [ detail => 100 ] => 'results'
-    ),
-  }
-
-If imported from Spliner, calling the C<reticulate> routine will be equivalent
-to:
-
-  Spliner->new->gather_data->analyze(detail => 100)->results;
-
-If any method returns something on which methods may not be called, the routine
-croaks.
-
-The arguments to C<curry_chain> form an optlist.  The names are methods to be
-called and the arguments, if given, are arrayrefs to be dereferenced and passed
-as arguments to those methods.  C<curry_chain> returns a generator like those
-expected by Sub::Exporter.
-
-B<Achtung!> at present, there is no way to pass arguments from the generated
-routine to the method calls.  This will probably be solved in future revisions
-by allowing the opt list's values to be subroutines that will be called with
-the generated routine's stack.
-
-=head2 merge_col
-
-  exports => {
-    merge_col(defaults => {
-      twiddle => \'_twiddle_gen',
-      tweak   => \&_tweak_gen,
-    }),
-  }
-
-This utility wraps the given generator in one that will merge the named
-collection into its args before calling it.  This means that you can support a
-"default" collector in multiple exports without writing the code each time.
-
-You can specify as many pairs of collection names and generators as you like.
-
-=head2 mixin_installer
-
-  use Sub::Exporter -setup => {
-    installer => Sub::Exporter::Util::mixin_installer,
-    exports   => [ qw(foo bar baz) ],
-  };
-
-This utility returns an installer that will install into a superclass and
-adjust the ISA importing class to include the newly generated superclass.
-
-If the target of importing is an object, the hierarchy is reversed: the new
-class will be ISA the object's class, and the object will be reblessed.
-
-B<Prerequisites>: This utility requires that Package::Generator be installed.
-
-=head2 like
-
-It's a collector that adds imports for anything like given regex.
-
-If you provide this configuration:
-
-  exports    => [ qw(igrep imap islurp exhausted) ],
-  collectors => { -like => Sub::Exporter::Util::like },
-
-A user may import from your module like this:
-
-  use Your::Iterator -like => qr/^i/; # imports igre, imap, islurp
-
-or
-
-  use Your::Iterator -like => [ qr/^i/ => { -prefix => 'your_' } ];
-
-The group-like prefix and suffix arguments are respected; other arguments are
-passed on to the generators for matching exports.
-
-=head1 AUTHOR
-
-Ricardo Signes <cpan@semiotic.systems>
-
-=head1 COPYRIGHT AND LICENSE
-
-This software is copyright (c) 2007 by Ricardo Signes.
-
-This is free software; you can redistribute it and/or modify it under
-the same terms as the Perl 5 programming language system itself.
-
-=cut