RubyGems - javonet-ruby-sdk - Versions diffs - 2.4.9 → 2.4.11 - Mend

javonet-ruby-sdk 2.4.9 → 2.4.11

Files changed (1457) hide show

data/lib/javonet-ruby-sdk/Binaries/Perl/MacOs/X64/deps/lib/perl5/PPI/Normal/Standard.pm DELETED Viewed

@@ -1,139 +0,0 @@
-package PPI::Normal::Standard;
-=pod
-=head1 NAME
-PPI::Normal::Standard - Provides standard document normalization functions
-=head1 DESCRIPTION
-This module provides the default normalization methods for L<PPI::Normal>.
-There is no reason for you to need to load this yourself.
-B<Move along, nothing to see here>.
-=cut
-use strict;
-our $VERSION = '1.279';
-#####################################################################
-# Configuration and Registration
-my @METHODS = (
-	remove_insignificant_elements => 1,
-	remove_useless_attributes     => 1,
-	remove_useless_pragma         => 2,
-	remove_statement_separator    => 2,
-	remove_useless_return         => 2,
-);
-sub import {
-	PPI::Normal->register(
-		map { /\D/ ? "PPI::Normal::Standard::$_" : $_ } @METHODS
-	) or die "Failed to register PPI::Normal::Standard transforms";
-}
-#####################################################################
-# Level 1 Transforms
-# Remove all insignificant elements
-sub remove_insignificant_elements {
-	my $Document = shift;
-	$Document->prune( sub { ! $_[1]->significant } );
-}
-# Remove custom attributes that are not relevant to normalization
-sub remove_useless_attributes {
-	my $Document = shift;
-	delete $Document->{tab_width};
-	### FIXME - Add support for more things
-}
-#####################################################################
-# Level 2 Transforms
-# Remove version dependencies and pragma
-my $remove_pragma = map { $_ => 1 } qw{
-	strict warnings diagnostics	less
-	};
-sub remove_useless_pragma {
-	my $Document = shift;
-	$Document->prune( sub {
-		return '' unless $_[1]->isa('PPI::Statement::Include');
-		return 1  if     $_[1]->version;
-		return 1  if     $remove_pragma->{$_[1]->pragma};
-		'';
-	} );
-}
-# Remove all semi-colons at the end of statements
-sub remove_statement_separator {
-	my $Document = shift;
-	$Document->prune( sub {
-		$_[1]->isa('PPI::Token::Structure') or return '';
-		$_[1]->content eq ';'               or return '';
-		my $stmt = $_[1]->parent            or return '';
-		$stmt->isa('PPI::Statement')        or return '';
-		$_[1]->next_sibling                and return '';
-		1;
-	} );
-}
-# In any block, the "return" in the last statement is not
-# needed if there is only one and only one thing after the
-# return.
-sub remove_useless_return {
-	my $Document = shift;
-	$Document->prune( sub {
-		$_[1]->isa('PPI::Token::Word')       or return '';
-		$_[1]->content eq 'return'           or return '';
-		my $stmt = $_[1]->parent             or return '';
-		$stmt->isa('PPI::Statement::Break')  or return '';
-		$stmt->children == 2                 or return '';
-		$stmt->next_sibling                 and return '';
-		my $block = $stmt->parent            or return '';
-		$block->isa('PPI::Structure::Block') or return '';
-		1;
-	} );
-}
-1;
-=pod
-=head1 SUPPORT
-See the L<support section|PPI/SUPPORT> in the main module.
-=head1 AUTHOR
-Adam Kennedy E<lt>adamk@cpan.orgE<gt>
-=head1 COPYRIGHT
-Copyright 2005 - 2011 Adam Kennedy.
-This program is free software; you can redistribute
-it and/or modify it under the same terms as Perl itself.
-The full text of the license can be found in the
-LICENSE file included with this module.
-=cut

data/lib/javonet-ruby-sdk/Binaries/Perl/MacOs/X64/deps/lib/perl5/PPI/Normal.pm DELETED Viewed

@@ -1,257 +0,0 @@
-package PPI::Normal;
-=pod
-=head1 NAME
-PPI::Normal - Normalize Perl Documents
-=head2 DESCRIPTION
-Perl Documents, as created by PPI, are typically filled with all sorts of
-mess such as whitespace and comments and other things that don't effect
-the actual meaning of the code.
-In addition, because there is more than one way to do most things, and the
-syntax of Perl itself is quite flexible, there are many ways in which the
-"same" code can look quite different.
-PPI::Normal attempts to resolve this by providing a variety of mechanisms
-and algorithms to "normalize" Perl Documents, and determine a sort of base
-form for them (although this base form will be a memory structure, and
-not something that can be turned back into Perl source code).
-The process itself is quite complex, and so for convenience and
-extensibility it has been separated into a number of layers. At a later
-point, it will be possible to write Plugin classes to insert additional
-normalization steps into the various different layers.
-In addition, you can choose to do the normalization only as deep as a
-particular layer, depending on aggressively you want the normalization
-process to be.
-=head1 METHODS
-=cut
-use strict;
-use Carp                      ();
-use List::Util 1.33           ();
-use PPI::Util                 '_Document';
-use PPI::Document::Normalized ();
-use PPI::Normal::Standard     ();
-use PPI::Singletons           '%LAYER';
-our $VERSION = '1.279';
-# With the registration mechanism in place, load in the main set of
-# normalization methods to initialize the store.
-PPI::Normal::Standard->import;
-#####################################################################
-# Configuration
-=pod
-=head2 register $function => $layer, ...
-The C<register> method is used by normalization method providers to
-tell the normalization engines which functions need to be run, and
-in which layer they apply.
-Provide a set of key/value pairs, where the key is the full name of the
-function (in string form), and the value is the layer (see description
-of the layers above) in which it should be run.
-Returns true if all functions are registered, or C<undef> on error.
-=cut
-sub register {
-	my $class = shift;
-	while ( @_ ) {
-		# Check the function
-		my $function = shift;
-		SCOPE: {
-			no strict 'refs';
-			defined $function and defined &{"$function"}
-				or Carp::croak("Bad function name provided to PPI::Normal");
-		}
-		# Has it already been added?
-		if ( List::Util::any { $_ eq $function } map @{$_}, values %LAYER ) {
-			return 1;
-		}
-		# Check the layer to add it to
-		my $layer = shift;
-		defined $layer and $layer =~ /^(?:1|2)$/
-			or Carp::croak("Bad layer provided to PPI::Normal");
-		# Add to the layer data store
-		push @{ $LAYER{$layer} }, $function;
-	}
-	1;
-}
-#####################################################################
-# Constructor and Accessors
-=pod
-=head2 new
-  my $level_1 = PPI::Normal->new;
-  my $level_2 = PPI::Normal->new(2);
-Creates a new normalization object, to which Document objects
-can be passed to be normalized.
-Of course, what you probably REALLY want is just to call
-L<PPI::Document>'s C<normalize> method.
-Takes an optional single parameter of the normalisation layer
-to use, which at this time can be either "1" or "2".
-Returns a new C<PPI::Normal> object, or C<undef> on error.
-=cut
-sub new {
-	my $class = shift;
-	my $layer = @_ ?
-		(defined $_[0] and ! ref $_[0] and $_[0] =~ /^[12]$/) ? shift : return undef
-		: 1;
-	# Create the object
-	my $object = bless {
-		layer => $layer,
-		}, $class;
-	$object;
-}
-=pod
-=head1 layer
-The C<layer> accessor returns the normalisation layer of the object.
-=cut
-sub layer { $_[0]->{layer} }
-#####################################################################
-# Main Methods
-=pod
-=head2 process
-The C<process> method takes anything that can be converted to a
-L<PPI::Document> (object, SCALAR ref, filename), loads it and
-applies the normalisation process to the document.
-Returns a L<PPI::Document::Normalized> object, or C<undef> on error.
-=cut
-sub process {
-	my $self = ref $_[0] ? shift : shift->new;
-	# PPI::Normal objects are reusable, but not re-entrant
-	return undef if $self->{Document};
-	# Get or create the document
-	$self->{Document} = _Document(shift) or return undef;
-	# Work out what functions we need to call
-	my @functions = map { @{ $LAYER{$_} } } ( 1 .. $self->layer );
-	# Execute each function
-	foreach my $function ( @functions ) {
-		no strict 'refs';
-		&{"$function"}( $self->{Document} );
-	}
-	# Create the normalized Document object
-	my $Normalized = PPI::Document::Normalized->new(
-		Document  => $self->{Document},
-		version   => __PACKAGE__->VERSION,
-		functions => \@functions,
-	) or return undef;
-	# Done, clean up
-	delete $self->{Document};
-	return $Normalized;
-}
-1;
-=pod
-=head1 NOTES
-The following normalisation layers are implemented. When writing
-plugins, you should register each transformation function with the
-appropriate layer.
-=head2 Layer 1 - Insignificant Data Removal
-The basic step common to all normalization, layer 1 scans through the
-Document and removes all whitespace, comments, POD, and anything else
-that returns false for its C<significant> method.
-It also checks each Element and removes known-useless sub-element
-metadata such as the Element's physical position in the file.
-=head2 Layer 2 - Significant Element Removal
-After the removal of the insignificant data, Layer 2 removed larger, more
-complex, and superficially "significant" elements, that can be removed
-for the purposes of normalisation.
-Examples from this layer include pragmas, now-useless statement
-separators (since the PDOM tree is holding statement elements), and
-several other minor bits and pieces.
-=head2 Layer 3 - TO BE COMPLETED
-This version of the forward-port of the Perl::Compare functionality
-to the 0.900+ API of PPI only implements Layer 1 and 2 at this time.
-=head1 TO DO
-- Write the other 4-5 layers :)
-=head1 SUPPORT
-See the L<support section|PPI/SUPPORT> in the main module.
-=head1 AUTHOR
-Adam Kennedy E<lt>adamk@cpan.orgE<gt>
-=head1 COPYRIGHT
-Copyright 2005 - 2011 Adam Kennedy.
-This program is free software; you can redistribute
-it and/or modify it under the same terms as Perl itself.
-The full text of the license can be found in the
-LICENSE file included with this module.
-=cut

data/lib/javonet-ruby-sdk/Binaries/Perl/MacOs/X64/deps/lib/perl5/PPI/Singletons.pm DELETED Viewed

@@ -1,92 +0,0 @@
-package PPI::Singletons;
-# exports some singleton variables to avoid aliasing magic
-use strict;
-use Exporter     ();
-our $VERSION = '1.279';
-our @ISA       = 'Exporter';
-our @EXPORT_OK = qw{ %_PARENT %_POSITION_CACHE %OPERATOR %MAGIC %LAYER $CURLY_SYMBOL %QUOTELIKE %KEYWORDS };
-our %_PARENT; # Master Child -> Parent index
-our %_POSITION_CACHE; # cache for position in parent
-# operator index
-our %OPERATOR = map { $_ => 1 } (
-	qw{
-	-> ++ -- ** ! ~ + -
-	=~ !~ * / % x . << >>
-	< > <= >= lt gt le ge
-	== != <=> eq ne cmp ~~
-	& | ^ && || // .. ...
-	? :
-	= **= += -= .= *= /= %= x= &= |= ^= <<= >>= &&= ||= //=
-	=> <> <<>>
-	and or xor not
-	}, ',' 	# Avoids "comma in qw{}" warning
-);
-# Magic variables taken from perlvar.
-# Several things added separately to avoid warnings.
-our %MAGIC = map { $_ => 1 } qw{
-	$1 $2 $3 $4 $5 $6 $7 $8 $9
-	$_ $& $` $' $+ @+ %+ $* $. $/ $|
-	$\\ $" $; $% $= $- @- %- $)
-	$~ $^ $: $? $! %! $@ $$ $< $>
-	$( $0 $[ $] @_ @*
-	$^L $^A $^E $^C $^D $^F $^H
-	$^I $^M $^N $^O $^P $^R $^S
-	$^T $^V $^W $^X %^H
-	$::|
-}, '$}', '$,', '$#', '$#+', '$#-';
-our %LAYER = ( 1 => [], 2 => [] );    # Registered function store
-our $CURLY_SYMBOL = qr{\G\^[[:upper:]_]\w+\}};
-our %QUOTELIKE = (
-	'q'  => 'Quote::Literal',
-	'qq' => 'Quote::Interpolate',
-	'qx' => 'QuoteLike::Command',
-	'qw' => 'QuoteLike::Words',
-	'qr' => 'QuoteLike::Regexp',
-	'm'  => 'Regexp::Match',
-	's'  => 'Regexp::Substitute',
-	'tr' => 'Regexp::Transliterate',
-	'y'  => 'Regexp::Transliterate',
-);
-# List of keywords is from regen/keywords.pl in the perl source.
-our %KEYWORDS = map { $_ => 1 } qw{
-	abs accept alarm and atan2 bind binmode bless break caller chdir chmod
-	chomp chop chown chr chroot close closedir cmp connect continue cos
-	crypt dbmclose dbmopen default defined delete die do dump each else
-	elsif endgrent endhostent endnetent endprotoent endpwent endservent
-	eof eq eval evalbytes exec exists exit exp fc fcntl fileno flock for
-	foreach fork format formline ge getc getgrent getgrgid getgrnam
-	gethostbyaddr gethostbyname gethostent getlogin getnetbyaddr
-	getnetbyname getnetent getpeername getpgrp getppid getpriority
-	getprotobyname getprotobynumber getprotoent getpwent getpwnam
-	getpwuid getservbyname getservbyport getservent getsockname
-	getsockopt given glob gmtime goto grep gt hex if index int ioctl join
-	keys kill last lc lcfirst le length link listen local localtime lock
-	log lstat lt m map mkdir msgctl msgget msgrcv msgsnd my ne next no
-	not oct open opendir or ord our pack package pipe pop pos print
-	printf prototype push q qq qr quotemeta qw qx rand read readdir
-	readline readlink readpipe recv redo ref rename require reset return
-	reverse rewinddir rindex rmdir s say scalar seek seekdir select semctl
-	semget semop send setgrent sethostent setnetent setpgrp
-	setpriority setprotoent setpwent setservent setsockopt shift shmctl
-	shmget shmread shmwrite shutdown sin sleep socket socketpair sort
-	splice split sprintf sqrt srand stat state study sub substr symlink
-	syscall sysopen sysread sysseek system syswrite tell telldir tie tied
-	time times tr truncate uc ucfirst umask undef unless unlink unpack
-	unshift untie until use utime values vec wait waitpid wantarray warn
-	when while write x xor y
-};
-1;

data/lib/javonet-ruby-sdk/Binaries/Perl/MacOs/X64/deps/lib/perl5/PPI/Statement/Break.pm DELETED Viewed

@@ -1,75 +0,0 @@
-package PPI::Statement::Break;
-=pod
-=head1 NAME
-PPI::Statement::Break - Statements which break out of normal statement flow
-=head1 SYNOPSIS
-  last;
-  goto FOO;
-  next if condition();
-  return $foo;
-  redo;
-=head1 INHERITANCE
-  PPI::Statement::Break
-  isa PPI::Statement
-      isa PPI::Node
-          isa PPI::Element
-=head1 DESCRIPTION
-C<PPI::Statement::Break> is intended to represent statements that break
-out of the normal statement flow control. This covers the basic
-types C<'redo'>, C<'goto'>, C<'next'>, C<'last'> and C<'return'>.
-=head1 METHODS
-C<PPI::Statement::Break> has no additional methods beyond the default ones
-provided by L<PPI::Statement>, L<PPI::Node> and L<PPI::Element>.
-However, it is expected to gain methods for identifying the line to break
-to, or the structure to break out of.
-=cut
-use strict;
-use PPI::Statement ();
-our $VERSION = '1.279';
-our @ISA = "PPI::Statement";
-1;
-=pod
-=head1 TO DO
-- Add the methods to identify the break target
-- Add some proper unit testing
-=head1 SUPPORT
-See the L<support section|PPI/SUPPORT> in the main module.
-=head1 AUTHOR
-Adam Kennedy E<lt>adamk@cpan.orgE<gt>
-=head1 COPYRIGHT
-Copyright 2001 - 2011 Adam Kennedy.
-This program is free software; you can redistribute
-it and/or modify it under the same terms as Perl itself.
-The full text of the license can be found in the
-LICENSE file included with this module.
-=cut