RubyGems - javonet-ruby-sdk - Versions diffs - 2.4.10 → 2.5.0 - Mend

javonet-ruby-sdk 2.4.10 → 2.5.0

Files changed (1538) hide show

data/lib/javonet-ruby-sdk/Binaries/Perl/MacOs/X64/deps/lib/perl5/darwin-thread-multi-2level/Moose/Cookbook/Basics/DateTime_ExtendingNonMooseParent.pod DELETED Viewed

@@ -1,127 +0,0 @@
-# PODNAME: Moose::Cookbook::Basics::DateTime_ExtendingNonMooseParent
-# ABSTRACT: Extending a non-Moose parent class
-__END__
-=pod
-=encoding UTF-8
-=head1 NAME
-Moose::Cookbook::Basics::DateTime_ExtendingNonMooseParent - Extending a non-Moose parent class
-=head1 VERSION
-version 2.2207
-=head1 SYNOPSIS
-  package My::DateTime;
-  use Moose;
-  use MooseX::NonMoose;
-  use DateTime::Calendar::Mayan;
-  extends qw( DateTime );
-  has 'mayan_date' => (
-      is        => 'ro',
-      isa       => 'DateTime::Calendar::Mayan',
-      init_arg  => undef,
-      lazy      => 1,
-      builder   => '_build_mayan_date',
-      clearer   => '_clear_mayan_date',
-      predicate => 'has_mayan_date',
-  );
-  after 'set' => sub {
-      $_[0]->_clear_mayan_date;
-  };
-  sub _build_mayan_date {
-      DateTime::Calendar::Mayan->from_object( object => $_[0] );
-  }
-=head1 DESCRIPTION
-This recipe demonstrates how to use Moose to subclass a parent which
-is not Moose based. This recipe only works if the parent class uses a
-blessed hash reference for object instances. If your parent is doing
-something funkier, you should check out L<MooseX::NonMoose::InsideOut> and L<MooseX::InsideOut>.
-The meat of this recipe is contained in L<MooseX::NonMoose>, which does all
-the grunt work for you.
-=for testing-SETUP use Test::Needs {
-    'DateTime'                  => '0',
-    'DateTime::Calendar::Mayan' => '0',
-    'MooseX::NonMoose'          => '0.25',
-};
-=begin testing
-my $dt = My::DateTime->new( year => 1970, month => 2, day => 24 );
-can_ok( $dt, 'mayan_date' );
-isa_ok( $dt->mayan_date, 'DateTime::Calendar::Mayan' );
-is( $dt->mayan_date->date, '12.17.16.9.19', 'got expected mayan date' );
-$dt->set( year => 2009 );
-ok( ! $dt->has_mayan_date, 'mayan_date is cleared after call to ->set' );
-=end testing
-=head1 AUTHORS
-=over 4
-=item *
-Stevan Little <stevan@cpan.org>
-=item *
-Dave Rolsky <autarch@urth.org>
-=item *
-Jesse Luehrs <doy@cpan.org>
-=item *
-Shawn M Moore <sartak@cpan.org>
-=item *
-יובל קוג'מן (Yuval Kogman) <nothingmuch@woobling.org>
-=item *
-Karen Etheridge <ether@cpan.org>
-=item *
-Florian Ragwitz <rafl@debian.org>
-=item *
-Hans Dieter Pearcey <hdp@cpan.org>
-=item *
-Chris Prather <chris@prather.org>
-=item *
-Matt S Trout <mstrout@cpan.org>
-=back
-=head1 COPYRIGHT AND LICENSE
-This software is copyright (c) 2006 by Infinity Interactive, Inc.
-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

data/lib/javonet-ruby-sdk/Binaries/Perl/MacOs/X64/deps/lib/perl5/darwin-thread-multi-2level/Moose/Cookbook/Basics/Document_AugmentAndInner.pod DELETED Viewed

@@ -1,197 +0,0 @@
-# PODNAME: Moose::Cookbook::Basics::Document_AugmentAndInner
-# ABSTRACT: The augment modifier, which turns normal method overriding "inside-out"
-__END__
-=pod
-=encoding UTF-8
-=head1 NAME
-Moose::Cookbook::Basics::Document_AugmentAndInner - The augment modifier, which turns normal method overriding "inside-out"
-=head1 VERSION
-version 2.2207
-=head1 SYNOPSIS
-  package Document::Page;
-  use Moose;
-  has 'body' => ( is => 'rw', isa => 'Str', default => sub {''} );
-  sub create {
-      my $self = shift;
-      $self->open_page;
-      inner();
-      $self->close_page;
-  }
-  sub append_body {
-      my ( $self, $appendage ) = @_;
-      $self->body( $self->body . $appendage );
-  }
-  sub open_page  { (shift)->append_body('<page>') }
-  sub close_page { (shift)->append_body('</page>') }
-  package Document::PageWithHeadersAndFooters;
-  use Moose;
-  extends 'Document::Page';
-  augment 'create' => sub {
-      my $self = shift;
-      $self->create_header;
-      inner();
-      $self->create_footer;
-  };
-  sub create_header { (shift)->append_body('<header/>') }
-  sub create_footer { (shift)->append_body('<footer/>') }
-  package TPSReport;
-  use Moose;
-  extends 'Document::PageWithHeadersAndFooters';
-  augment 'create' => sub {
-      my $self = shift;
-      $self->create_tps_report;
-      inner();
-  };
-  sub create_tps_report {
-      (shift)->append_body('<report type="tps"/>');
-  }
-  # <page><header/><report type="tps"/><footer/></page>
-  my $report_xml = TPSReport->new->create;
-=head1 DESCRIPTION
-This recipe shows how the C<augment> method modifier works. This
-modifier reverses the normal subclass to parent method resolution
-order. With an C<augment> modifier the I<least> specific method is
-called first. Each successive call to C<inner> descends the
-inheritance tree, ending at the most specific subclass.
-The C<augment> modifier lets you design a parent class that can be
-extended in a specific way. The parent provides generic wrapper
-functionality, and the subclasses fill in the details.
-In the example above, we've created a set of document classes, with
-the most specific being the C<TPSReport> class.
-We start with the least specific class, C<Document::Page>. Its create
-method contains a call to C<inner()>:
-  sub create {
-      my $self = shift;
-      $self->open_page;
-      inner();
-      $self->close_page;
-  }
-The C<inner> function is exported by C<Moose>, and is like C<super>
-for augmented methods. When C<inner> is called, Moose finds the next
-method in the chain, which is the C<augment> modifier in
-C<Document::PageWithHeadersAndFooters>. You'll note that we can call
-C<inner> in our modifier:
-  augment 'create' => sub {
-      my $self = shift;
-      $self->create_header;
-      inner();
-      $self->create_footer;
-  };
-This finds the next most specific modifier, in the C<TPSReport> class.
-Finally, in the C<TPSReport> class, the chain comes to an end:
-  augment 'create' => sub {
-      my $self = shift;
-      $self->create_tps_report;
-      inner();
-  };
-We do call the C<inner> function one more time, but since there is no
-more specific subclass, this is a no-op. Making this call means we can
-easily subclass C<TPSReport> in the future.
-=head1 CONCLUSION
-The C<augment> modifier is a powerful tool for creating a set of
-nested wrappers. It's not something you will need often, but when you
-do, it is very handy.
-=begin testing
-my $tps_report = TPSReport->new;
-isa_ok( $tps_report, 'TPSReport' );
-is(
-    $tps_report->create,
-    q{<page><header/><report type="tps"/><footer/></page>},
-    '... got the right TPS report'
-);
-=end testing
-=head1 AUTHORS
-=over 4
-=item *
-Stevan Little <stevan@cpan.org>
-=item *
-Dave Rolsky <autarch@urth.org>
-=item *
-Jesse Luehrs <doy@cpan.org>
-=item *
-Shawn M Moore <sartak@cpan.org>
-=item *
-יובל קוג'מן (Yuval Kogman) <nothingmuch@woobling.org>
-=item *
-Karen Etheridge <ether@cpan.org>
-=item *
-Florian Ragwitz <rafl@debian.org>
-=item *
-Hans Dieter Pearcey <hdp@cpan.org>
-=item *
-Chris Prather <chris@prather.org>
-=item *
-Matt S Trout <mstrout@cpan.org>
-=back
-=head1 COPYRIGHT AND LICENSE
-This software is copyright (c) 2006 by Infinity Interactive, Inc.
-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

data/lib/javonet-ruby-sdk/Binaries/Perl/MacOs/X64/deps/lib/perl5/darwin-thread-multi-2level/Moose/Cookbook/Basics/Genome_OverloadingSubtypesAndCoercion.pod DELETED Viewed

@@ -1,318 +0,0 @@
-# PODNAME: Moose::Cookbook::Basics::Genome_OverloadingSubtypesAndCoercion
-# ABSTRACT: Operator overloading, subtypes, and coercion
-__END__
-=pod
-=encoding UTF-8
-=head1 NAME
-Moose::Cookbook::Basics::Genome_OverloadingSubtypesAndCoercion - Operator overloading, subtypes, and coercion
-=head1 VERSION
-version 2.2207
-=head1 SYNOPSIS
-  package Human;
-  use Moose;
-  use Moose::Util::TypeConstraints;
-  subtype 'Sex'
-      => as 'Str'
-      => where { $_ =~ m{^[mf]$}s };
-  has 'sex'    => ( is => 'ro', isa => 'Sex', required => 1 );
-  has 'mother' => ( is => 'ro', isa => 'Human' );
-  has 'father' => ( is => 'ro', isa => 'Human' );
-  use overload '+' => \&_overload_add, fallback => 1;
-  sub _overload_add {
-      my ( $one, $two ) = @_;
-      die('Only male and female humans may create children')
-          if ( $one->sex() eq $two->sex() );
-      my ( $mother, $father )
-          = ( $one->sex eq 'f' ? ( $one, $two ) : ( $two, $one ) );
-      my $sex = 'f';
-      $sex = 'm' if ( rand() >= 0.5 );
-      return Human->new(
-          sex    => $sex,
-          mother => $mother,
-          father => $father,
-      );
-  }
-=head1 DESCRIPTION
-This Moose cookbook recipe shows how operator overloading, coercion,
-and subtypes can be used to mimic the human reproductive system
-(well, the selection of genes at least).
-=head1 INTRODUCTION
-Our C<Human> class uses operator overloading to allow us to "add" two
-humans together and produce a child. Our implementation does require
-that the two objects be of opposite sex. Remember, we're talking
-about biological reproduction, not marriage.
-While this example works as-is, we can take it a lot further by adding
-genes into the mix. We'll add the two genes that control eye color,
-and use overloading to combine the genes from the parent to model the
-biology.
-=head2 What is Operator Overloading?
-Overloading is I<not> a Moose-specific feature. It's a general OO
-concept that is implemented in Perl with the C<overload>
-pragma. Overloading lets objects do something sane when used with
-Perl's built in operators, like addition (C<+>) or when used as a
-string.
-In this example we overload addition so we can write code like
-C<$child = $mother + $father>.
-=head1 GENES
-There are many genes which affect eye color, but there are two which
-are most important, I<gey> and I<bey2>. We will start by making a
-class for each gene.
-=head2 Human::Gene::bey2
-  package Human::Gene::bey2;
-  use Moose;
-  use Moose::Util::TypeConstraints;
-  type 'bey2_color' => where { $_ =~ m{^(?:brown|blue)$} };
-  has 'color' => ( is => 'ro', isa => 'bey2_color' );
-This class is trivial. We have a type constraint for the allowed
-colors, and a C<color> attribute.
-=head2 Human::Gene::gey
-  package Human::Gene::gey;
-  use Moose;
-  use Moose::Util::TypeConstraints;
-  type 'gey_color' => where { $_ =~ m{^(?:green|blue)$} };
-  has 'color' => ( is => 'ro', isa => 'gey_color' );
-This is nearly identical to the C<Humane::Gene::bey2> class, except
-that the I<gey> gene allows for different colors.
-=head1 EYE COLOR
-We could just give four attributes (two of each gene) to the
-C<Human> class, but this is a bit messy. Instead, we'll abstract the
-genes into a container class, C<Human::EyeColor>. Then a C<Human> can
-have a single C<eye_color> attribute.
-  package Human::EyeColor;
-  use Moose;
-  use Moose::Util::TypeConstraints;
-  coerce 'Human::Gene::bey2'
-      => from 'Str'
-          => via { Human::Gene::bey2->new( color => $_ ) };
-  coerce 'Human::Gene::gey'
-      => from 'Str'
-          => via { Human::Gene::gey->new( color => $_ ) };
-  has [qw( bey2_1 bey2_2 )] =>
-      ( is => 'ro', isa => 'Human::Gene::bey2', coerce => 1 );
-  has [qw( gey_1 gey_2 )] =>
-      ( is => 'ro', isa => 'Human::Gene::gey', coerce => 1 );
-The eye color class has two of each type of gene. We've also created a
-coercion for each class that coerces a string into a new object. Note
-that a coercion will fail if it attempts to coerce a string like
-"indigo", because that is not a valid color for either type of gene.
-As an aside, you can see that we can define several identical
-attributes at once by supplying an array reference of names as the first
-argument to C<has>.
-We also need a method to calculate the actual eye color that results
-from a set of genes. The I<bey2> brown gene is dominant over both blue
-and green. The I<gey> green gene is dominant over blue.
-  sub color {
-      my ($self) = @_;
-      return 'brown'
-          if ( $self->bey2_1->color() eq 'brown'
-          or $self->bey2_2->color() eq 'brown' );
-      return 'green'
-          if ( $self->gey_1->color() eq 'green'
-          or $self->gey_2->color() eq 'green' );
-      return 'blue';
-  }
-We'd like to be able to treat a C<Human::EyeColor> object as a string,
-so we define a string overloading for the class:
-  use overload '""' => \&color, fallback => 1;
-Finally, we need to define overloading for addition. That way we can
-add together two C<Human::EyeColor> objects and get a new one with a
-new (genetically correct) eye color.
-  use overload '+' => \&_overload_add, fallback => 1;
-  sub _overload_add {
-      my ( $one, $two ) = @_;
-      my $one_bey2 = 'bey2_' . _rand2();
-      my $two_bey2 = 'bey2_' . _rand2();
-      my $one_gey = 'gey_' . _rand2();
-      my $two_gey = 'gey_' . _rand2();
-      return Human::EyeColor->new(
-          bey2_1 => $one->$one_bey2->color(),
-          bey2_2 => $two->$two_bey2->color(),
-          gey_1  => $one->$one_gey->color(),
-          gey_2  => $two->$two_gey->color(),
-      );
-  }
-  sub _rand2 {
-      return 1 + int( rand(2) );
-  }
-When two eye color objects are added together, the C<_overload_add()>
-method will be passed two C<Human::EyeColor> objects. These are the
-left and right side operands for the C<+> operator. This method
-returns a new C<Human::EyeColor> object.
-=head1 ADDING EYE COLOR TO C<Human>s
-Our original C<Human> class requires just a few changes to incorporate
-our new C<Human::EyeColor> class.
-  use List::Util 1.56 qw( mesh );
-  coerce 'Human::EyeColor'
-      => from 'ArrayRef'
-      => via { my @genes = qw( bey2_1 bey2_2 gey_1 gey_2 );
-               return Human::EyeColor->new( mesh ( \@genes, $_ ) ); };
-  has 'eye_color' => (
-      is       => 'ro',
-      isa      => 'Human::EyeColor',
-      coerce   => 1,
-      required => 1,
-  );
-We also need to modify C<_overload_add()> in the C<Human> class to
-account for eye color:
-  return Human->new(
-      sex       => $sex,
-      eye_color => ( $one->eye_color() + $two->eye_color() ),
-      mother    => $mother,
-      father    => $father,
-  );
-=head1 CONCLUSION
-The three techniques we used, overloading, subtypes, and coercion,
-combine to provide a powerful interface.
-If you'd like to learn more about overloading, please read the
-documentation for the L<overload> pragma.
-To see all the code we created together, take a look at
-F<t/recipes/basics_genome_overloadingsubtypesandcoercion.t>.
-=head1 NEXT STEPS
-Had this been a real project we'd probably want:
-=over 4
-=item Better Randomization with Crypt::Random
-=item Characteristic Base Class
-=item Mutating Genes
-=item More Characteristics
-=item Artificial Life
-=back
-=head1 AUTHORS
-=over 4
-=item *
-Stevan Little <stevan@cpan.org>
-=item *
-Dave Rolsky <autarch@urth.org>
-=item *
-Jesse Luehrs <doy@cpan.org>
-=item *
-Shawn M Moore <sartak@cpan.org>
-=item *
-יובל קוג'מן (Yuval Kogman) <nothingmuch@woobling.org>
-=item *
-Karen Etheridge <ether@cpan.org>
-=item *
-Florian Ragwitz <rafl@debian.org>
-=item *
-Hans Dieter Pearcey <hdp@cpan.org>
-=item *
-Chris Prather <chris@prather.org>
-=item *
-Matt S Trout <mstrout@cpan.org>
-=back
-=head1 COPYRIGHT AND LICENSE
-This work is licensed under a Creative Commons Attribution 3.0 Unported License.
-License details are at: L<http://creativecommons.org/licenses/by/3.0/>
-=cut