Parse-Method-Signatures-1.003019/0000755000175000017500000000000013072454026015050 5ustar kentkentParse-Method-Signatures-1.003019/Changes0000644000175000017500000000507013072452365016351 0ustar kentkentChangelog for Parse::Method::Signatures 1.003019 - 2017/04/10 - Stable release of fixes in 1.003018_01 1.003018_01 - 2017/04/02 - Avoid needing '.' in @INC for Makefile.PL ( RT #120830 ) 1.003017 - 2016/05/31 - Fix use of unescaped "{" in QR ( RT #114385 ) 1.003016 - 2014/01/12 - Use Class::Load instead of Class::MOP::load_class() (Zefram) 1.003015 - 2013/03/01 - Don't ship MYMETA files 1.003014 - 2011/09/12 - Don't look in the stash for type names containing :: (Jesse Luehrs) 1.003013 - 2010/01/08 - Add version to List::MoreUtils as we need part() (Leo Lapworth) 1.003012 - 2009/12/16 - Pass from_namespace to type constraint class even if there is a callback provided. (This lets the callback be wrapped/extended better.) 1.003011 - 2009/08/18 - Resolve aliased type names when a namespace to look aliases up is given. 1.003010 - 2009/07/30 - Make it work with upcomming PPI 1.204 1.003009 - 2009/07/16 - Fix 'Use of uninitialized value' when using regexps in signatures - Depend on MooseX::Traits 0.06 to remove warning about 'bare has' attribute 1.003008 - 2009/06/25 - Fix ppi.t for the __MOP__ object key (Jesse Luehrs). 1.003007 - 2009/05/24 - Document Parse::Method::Signatures::Sig (Cory Watson) 1.003006 - 2009/05/19 - Copyright notice to make Debian packagers happy 1.003005 - 2009/05/07 - Stop using json in META.yml. 1.003004 - 2009/03/26 - Better error reporting of invalid TCs. - Better error reporting of not yet defined MX::Types TCs - We now skip leading whitespace at the start of the parse. Whitespce everywhere else is already skipped 1.003003 - 2009/03/16 - Re-introduce remaining_input since TryCatch depends upon it - Add more and update docs - Add 'from_namespace' option to streamline use with MooseX::Types 1.003002 - 2009/03/04 - Now *really* remove deps on Data::Dump. Not my day w.r.t. dists 1.003001 - 2009/03/04 - Remove unmarked test dependency on Data::Dump 1.003000 - 2009/03/03 - Port to using PPI to do the parsing - Produces nicer error messages - Refactor internals to be much more readable (thanks to Piers Cawley) 1.002000 - 2009/02/21 - Will now build a Moose TC object for types of params - Add a few more docs 1.001001 - 2009/01/31 - Handle fat commas in TCs (for MooseX::Types::Structured's Dict) - Add missing dep on Test::Differences 1.001000 - 2009/01/31 - Change how TCs are stored and parse for better support in reconstructing types at runtime - Switch to MooseX::Types - Support traits (e.g. does coerce) on params 1.000000 - 2009/01/05 - Initial release Parse-Method-Signatures-1.003019/lib/0000755000175000017500000000000013072454026015616 5ustar kentkentParse-Method-Signatures-1.003019/lib/Parse/0000755000175000017500000000000013072454026016670 5ustar kentkentParse-Method-Signatures-1.003019/lib/Parse/Method/0000755000175000017500000000000013072454026020110 5ustar kentkentParse-Method-Signatures-1.003019/lib/Parse/Method/Signatures/0000755000175000017500000000000013072454026022234 5ustar kentkentParse-Method-Signatures-1.003019/lib/Parse/Method/Signatures/Param.pm0000644000175000017500000000732013067734450023642 0ustar kentkentpackage Parse::Method::Signatures::Param; use Moose; use MooseX::Types::Structured qw/Tuple/; use MooseX::Types::Moose qw/Bool Str ArrayRef HashRef/; use namespace::clean -except => 'meta'; with 'MooseX::Traits'; has required => ( is => 'ro', isa => Bool, required => 1 ); has sigil => ( is => 'ro', isa => Str, required => 1, ); has type_constraints => ( is => 'ro', isa => 'Parse::Method::Signatures::TypeConstraint', predicate => 'has_type_constraints', handles => { meta_type_constraint => 'tc' }, ); has default_value => ( is => 'ro', isa => Str, predicate => 'has_default_value', ); has constraints => ( is => 'ro', isa => ArrayRef[Str], predicate => 'has_constraints', auto_deref => 1, ); has param_traits => ( is => 'ro', isa => ArrayRef[Tuple[Str, Str]], predicate => 'has_traits', auto_deref => 1 ); has '+_trait_namespace' => ( default => 'Parse::Method::Signatures::Param', ); sub _stringify_type_constraints { my ($self) = @_; return $self->has_type_constraints ? $self->type_constraints->to_string . q{ } : q{}; } sub _stringify_default_value { my ($self) = @_; return $self->has_default_value ? q{ = } . $self->default_value : q{}; } sub _stringify_constraints { my ($self) = @_; return q{} unless $self->has_constraints; return q{ where } . join(q{ where }, $self->constraints); } sub _stringify_traits { my ($self) = @_; return q{} unless $self->has_traits; return q{ } . join q{ }, map { @{ $_ } } $self->param_traits; } sub to_string { my ($self) = @_; my $ret = q{}; $ret .= $self->_stringify_type_constraints; $ret .= $self->_stringify_variable_name; $ret .= $self->_stringify_required; $ret .= $self->_stringify_default_value; $ret .= $self->_stringify_constraints; $ret .= $self->_stringify_traits; return $ret; } __PACKAGE__->meta->make_immutable; 1; =head1 NAME Parse::Method::Signatures::Param - a parsed parameter from a signature =head1 ATTRIBUTES All attributes of this class are read-only. =head2 required Is this parameter required (true) or optional (false)? =head2 sigil The effective sigil ('$', '@' or '%') of this parameter. =head2 type_constraints =over B L B has_type_constraints =back Representation of the type constraint for this parameter. Most commonly you will just call L and not access this attribute directly. =head2 default_value =over B Str B has_default_value =back A string that should be eval'd or injected to get the default value for this parameter. For example: $name = 'bar' Would give a default_value of "'bar'". =head2 constraints =over B ArrayRef[Str] B has_constraints =back C constraints for this type. Each member of the array a the string (including enclosing braces) of the where constraint block. =head2 param_traits =over B ArrayRef[ Tupple[Str,Str] ] B has_traits =back Traits that this parameter is declared to have. For instance $foo does coerce would have a trait of ['does', 'coerce'] =head1 METHODS =head2 to_string =head2 meta_type_constraint Get the L for this parameter. Check first that the type has a type constraint: $tc = $param->meta_type_constraint if $param->has_type_constraints; =head1 SEE ALSO L. =head1 AUTHORS Ash Berlin . Florian Ragwitz . =head1 LICENSE Licensed under the same terms as Perl itself. Parse-Method-Signatures-1.003019/lib/Parse/Method/Signatures/TypeConstraint.pm0000644000175000017500000001203113067734450025563 0ustar kentkentpackage Parse::Method::Signatures::TypeConstraint; use Carp qw/croak carp/; use Moose; use MooseX::Types::Util qw/has_available_type_export/; use MooseX::Types::Moose qw/Str HashRef CodeRef ClassName/; use Parse::Method::Signatures::Types qw/TypeConstraint/; use namespace::clean -except => 'meta'; has ppi => ( is => 'ro', isa => 'PPI::Element', required => 1, handles => { 'to_string' => 'content' } ); has tc => ( is => 'ro', isa => TypeConstraint, lazy => 1, builder => '_build_tc', ); has from_namespace => ( is => 'ro', isa => ClassName, predicate => 'has_from_namespace' ); has tc_callback => ( is => 'ro', isa => CodeRef, default => sub { \&find_registered_constraint }, ); sub find_registered_constraint { my ($self, $name) = @_; my $type; if ($self->has_from_namespace) { my $pkg = $self->from_namespace; if ($type = has_available_type_export($pkg, $name)) { croak "The type '$name' was found in $pkg " . "but it hasn't yet been defined. Perhaps you need to move the " . "definition into a type library or a BEGIN block.\n" if $type && $type->isa('MooseX::Types::UndefinedType'); } elsif ($name !~ /::/) { my $meta = Class::MOP::class_of($pkg) || Class::MOP::Class->initialize($pkg); my $func = $meta->get_package_symbol('&' . $name); my $proto = prototype $func if $func; $name = $func->() if $func && defined $proto && !length $proto; } } my $registry = Moose::Util::TypeConstraints->get_type_constraint_registry; return $type || $registry->find_type_constraint($name) || $name; } sub _build_tc { my ($self) = @_; my $tc = $self->_walk_data($self->ppi); # This makes the error appear from the right place local $Carp::Internal{'Class::MOP::Method::Generated'} = 1 unless exists $Carp::Internal{'Class::MOP::Method::Generated'}; croak "'@{[$self->ppi]}' could not be parsed to a type constraint - maybe you need to " . "pre-declare the type with class_type" unless blessed $tc; return $tc; } sub _walk_data { my ($self, $data) = @_; my $res = $self->_union_node($data) || $self->_params_node($data) || $self->_str_node($data) || $self->_leaf($data) or confess 'failed to visit tc'; return $res->(); } sub _leaf { my ($self, $data) = @_; sub { $self->_invoke_callback($data->content) }; } sub _union_node { my ($self, $data) = @_; return unless $data->isa('PPI::Statement::Expression::TCUnion'); my @types = map { $self->_walk_data($_) } $data->children; sub { scalar @types == 1 ? @types : Moose::Meta::TypeConstraint::Union->new(type_constraints => \@types) }; } sub _params_node { my ($self, $data) = @_; return unless $data->isa('PPI::Statement::Expression::TCParams'); my @params = map { $self->_walk_data($_) } @{$data->params}; my $type = $self->_invoke_callback($data->type); sub { $type->parameterize(@params) } } sub _str_node { my ($self, $data) = @_; return unless $data->isa('PPI::Token::StringifiedWord') || $data->isa('PPI::Token::Number') || $data->isa('PPI::Token::Quote'); sub { $data->isa('PPI::Token::Number') ? $data->content : $data->string }; } sub _invoke_callback { my $self = shift; $self->tc_callback->($self, @_); } __PACKAGE__->meta->make_immutable; 1; __END__ =head1 NAME Parse::Method::Signatures::TypeConstraint - turn parsed TC data into Moose TC object =head1 DESCRIPTION Class used to turn PPI elements into L objects. =head1 ATTRIBUTES =head2 tc =over B =back The L object for this type constraint, built when requested. L will be called for each individual component type in turn. =head2 tc_callback =over B CodeRef B L =back Callback used to turn type names into type objects. See L for more details and an example. =head2 from_namespace =over B ClassName =back If provided, then the default C will search for L in this package. =head1 METHODS =head2 find_registered_constraint Will search for an imported L in L (if provided). Failing that it will ask the L for a type with the given name. If all else fails, it will simple return the type as a string, so that Moose's auto-vivification of classnames to type will work. =head2 to_string String representation of the type constraint, approximately as parsed. =head1 SEE ALSO L, L, L. =head1 AUTHORS Florian Ragwitz . Ash Berlin . =head1 LICENSE Licensed under the same terms as Perl itself. Parse-Method-Signatures-1.003019/lib/Parse/Method/Signatures/Param/0000755000175000017500000000000013072454026023274 5ustar kentkentParse-Method-Signatures-1.003019/lib/Parse/Method/Signatures/Param/Placeholder.pm0000644000175000017500000000030513067734450026060 0ustar kentkentpackage Parse::Method::Signatures::Param::Placeholder; use Moose::Role; use namespace::clean -except => 'meta'; sub _stringify_variable_name { my ($self) = @_; return $self->sigil; } 1; Parse-Method-Signatures-1.003019/lib/Parse/Method/Signatures/Param/Bindable.pm0000644000175000017500000000053113067734450025337 0ustar kentkentpackage Parse::Method::Signatures::Param::Bindable; use Moose::Role; use Parse::Method::Signatures::Types qw/VariableName/; use namespace::clean -except => 'meta'; has variable_name => ( is => 'ro', isa => VariableName, required => 1, ); sub _stringify_variable_name { my ($self) = @_; return $self->variable_name; } 1; Parse-Method-Signatures-1.003019/lib/Parse/Method/Signatures/Param/Positional.pm0000644000175000017500000000031713067734450025762 0ustar kentkentpackage Parse::Method::Signatures::Param::Positional; use Moose::Role; use namespace::clean -except => 'meta'; sub _stringify_required { my ($self) = @_; return $self->required ? q{} : q{?}; } 1; Parse-Method-Signatures-1.003019/lib/Parse/Method/Signatures/Param/Unpacked.pm0000644000175000017500000000055413067734450025376 0ustar kentkentpackage Parse::Method::Signatures::Param::Unpacked; use Moose::Role; use Parse::Method::Signatures::Types qw/ParamCollection/; use namespace::clean -except => 'meta'; has _params => ( is => 'ro', isa => ParamCollection, init_arg => 'params', predicate => 'has_params', coerce => 1, handles => { params => 'params', }, ); 1; Parse-Method-Signatures-1.003019/lib/Parse/Method/Signatures/Param/Unpacked/0000755000175000017500000000000013072454026025026 5ustar kentkentParse-Method-Signatures-1.003019/lib/Parse/Method/Signatures/Param/Unpacked/Array.pm0000644000175000017500000000042613067734450026452 0ustar kentkentpackage Parse::Method::Signatures::Param::Unpacked::Array; use Moose::Role; use namespace::clean -except => 'meta'; with 'Parse::Method::Signatures::Param::Unpacked'; sub _stringify_variable_name { my ($self) = @_; return '[' . $self->_params->to_string . ']'; } 1; Parse-Method-Signatures-1.003019/lib/Parse/Method/Signatures/Param/Unpacked/Hash.pm0000644000175000017500000000042513067734450026256 0ustar kentkentpackage Parse::Method::Signatures::Param::Unpacked::Hash; use Moose::Role; use namespace::clean -except => 'meta'; with 'Parse::Method::Signatures::Param::Unpacked'; sub _stringify_variable_name { my ($self) = @_; return '{' . $self->_params->to_string . '}'; } 1; Parse-Method-Signatures-1.003019/lib/Parse/Method/Signatures/Param/Named.pm0000644000175000017500000000170313067734450024665 0ustar kentkentpackage Parse::Method::Signatures::Param::Named; use Moose::Role; use MooseX::Types::Moose qw/Str/; use namespace::clean -except => 'meta'; has label => ( is => 'ro', isa => Str, lazy_build => 1, ); sub _label_from_variable_name { my ($self) = @_; # strip sigil return substr($self->variable_name, 1); } sub _build_label { my ($self) = @_; return $self->_label_from_variable_name; } sub _stringify_required { my ($self) = @_; return $self->required ? q{!} : q{}; } around _stringify_variable_name => sub { my $orig = shift; my ($self) = @_; my $ret = q{:}; my ($before, $after) = (q{}) x 2; my $implicit_label = $self->_label_from_variable_name if $self->can('variable_name'); if (!$implicit_label || $self->label ne $implicit_label) { $before = $self->label . q{(}; $after = q{)}; } $ret .= $before . $orig->(@_) . $after; return $ret; }; 1; Parse-Method-Signatures-1.003019/lib/Parse/Method/Signatures/Sig.pm0000644000175000017500000000623313067734450023326 0ustar kentkentpackage Parse::Method::Signatures::Sig; use Moose; use MooseX::Types::Moose qw/HashRef/; use Parse::Method::Signatures::Types qw/Param ParamCollection NamedParam/; use List::MoreUtils qw/part/; use namespace::clean -except => 'meta'; has invocant => ( is => 'ro', does => Param, predicate => 'has_invocant', ); has _positional_params => ( is => 'ro', isa => ParamCollection, init_arg => 'positional_params', predicate => 'has_positional_params', coerce => 1, handles => { positional_params => 'params', }, ); has _named_params => ( is => 'ro', isa => ParamCollection, init_arg => 'named_params', predicate => 'has_named_params', coerce => 1, handles => { named_params => 'params', }, ); has _named_map => ( is => 'ro', isa => HashRef[Param], lazy_build => 1, ); override BUILDARGS => sub { my $args = super(); if (my $params = delete $args->{params}) { my ($positional, $named) = part { NamedParam->check($_) ? 1 : 0 } @{ $params }; $args->{positional_params} = $positional if $positional; $args->{named_params} = $named if $named; } return $args; }; sub _build__named_map { my ($self) = @_; return {} unless $self->has_named_params; return { map { $_->label => $_ } @{ $self->named_params } }; } sub named_param { my ($self, $name) = @_; return $self->_named_map->{$name}; } around has_positional_params => sub { my $orig = shift; my $ret = $orig->(@_); return unless $ret; my ($self) = @_; return scalar @{ $self->positional_params }; }; around has_named_params => sub { my $orig = shift; my $ret = $orig->(@_); return unless $ret; my ($self) = @_; return scalar @{ $self->named_params }; }; sub to_string { my ($self) = @_; my $ret = q{(}; if ($self->has_invocant) { $ret .= $self->invocant->to_string; $ret .= q{:}; if ($self->has_positional_params || $self->has_named_params) { $ret .= q{ }; } } $ret .= $self->_positional_params->to_string if $self->has_positional_params; $ret .= q{, } if $self->has_positional_params && $self->has_named_params; $ret .= $self->_named_params->to_string if $self->has_named_params; $ret .= q{)}; return $ret; } __PACKAGE__->meta->make_immutable; 1; __END__ =head1 NAME Parse::Method::Signatures::Sig - Method Signature =head1 DESCRIPTION Represents the parsed method signature. =head1 ATTRIBUTES =head2 invocant =head2 named_params A ParamCollection representing the name parameters of this signature. =head2 positional_params A ParamCollection representing the positional parameters of this signature. =head1 METHODS =head2 has_named_params Predicate returning true if this signature has named parameters. =head2 has_positional_params Predicate returning true if this signature has positional parameters. =head2 named_param Returns the Param with the specified name. =head2 to_string Returns a string representation of this signature. =head1 LICENSE Licensed under the same terms as Perl itself. =cut Parse-Method-Signatures-1.003019/lib/Parse/Method/Signatures/ParamCollection.pm0000644000175000017500000000064213067734450025656 0ustar kentkentpackage Parse::Method::Signatures::ParamCollection; use Moose; use MooseX::Types::Moose qw/ArrayRef/; use Parse::Method::Signatures::Types qw/Param/; use namespace::clean -except => 'meta'; has params => ( is => 'ro', isa => ArrayRef[Param], required => 1, auto_deref => 1, ); sub to_string { my ($self) = @_; return join(q{, }, map { $_->to_string } $self->params); } 1; Parse-Method-Signatures-1.003019/lib/Parse/Method/Signatures/Types.pm0000644000175000017500000000204313067734450023703 0ustar kentkentuse strict; use warnings; package Parse::Method::Signatures::Types; use Moose::Util::TypeConstraints; use MooseX::Types::Moose qw/Str ArrayRef/; use namespace::clean; use MooseX::Types -declare => [qw/ VariableName TypeConstraint Param ParamCollection PositionalParam NamedParam UnpackedParam /]; subtype VariableName, as Str, where { /^[\$@%](?:[a-z_][a-z_\d]*)?$/i }, message { 'not a valid variable name' }; subtype TypeConstraint, as 'Moose::Meta::TypeConstraint'; class_type Param, { class => 'Parse::Method::Signatures::Param' }; class_type ParamCollection, { class => 'Parse::Method::Signatures::ParamCollection' }; coerce ParamCollection, from ArrayRef, via { Parse::Method::Signatures::ParamCollection->new(params => $_) }; role_type PositionalParam, { role => 'Parse::Method::Signatures::Param::Positional' }; role_type NamedParam, { role => 'Parse::Method::Signatures::Param::Named' }; role_type UnpackedParam, { role => 'Parse::Method::Signatures::Param::Unpacked' }; 1; Parse-Method-Signatures-1.003019/lib/Parse/Method/Signatures.pm0000644000175000017500000006003613072453550022600 0ustar kentkentpackage Parse::Method::Signatures; use Moose; use MooseX::Types::Moose qw/ ArrayRef HashRef ScalarRef CodeRef Int Str ClassName /; use Class::Load qw(load_class); use PPI; use Moose::Util::TypeConstraints; use Parse::Method::Signatures::ParamCollection; use Parse::Method::Signatures::Types qw/ PositionalParam NamedParam UnpackedParam /; use Carp qw/croak/; use namespace::clean -except => 'meta'; our $VERSION = '1.003019'; $VERSION = eval $VERSION; our $ERROR_LEVEL = 0; our %LEXTABLE; our $DEBUG = $ENV{PMS_DEBUG} || 0; # Setup what we need for specific PPI subclasses @PPI::Token::EOF::ISA = 'PPI::Token'; class_type "PPI::Document"; class_type "PPI::Element"; has 'input' => ( is => 'ro', isa => Str, required => 1 ); has 'offset' => ( is => 'rw', isa => Int, default => 0, ); has 'signature_class' => ( is => 'ro', isa => Str, default => 'Parse::Method::Signatures::Sig', ); has 'param_class' => ( is => 'ro', isa => Str, default => 'Parse::Method::Signatures::Param', ); has 'type_constraint_class' => ( is => 'ro', isa => Str, default => 'Parse::Method::Signatures::TypeConstraint', ); has 'type_constraint_callback' => ( is => 'ro', isa => CodeRef, predicate => 'has_type_constraint_callback', ); has 'from_namespace' => ( is => 'rw', isa => ClassName, predicate => 'has_from_namespace' ); has 'ppi_doc' => ( is => 'ro', isa => 'PPI::Document', lazy_build => 1, builder => 'parse', ); # A bit dirty, but we set this with local most of the time has 'ppi' => ( is => 'ro', isa => 'PPI::Element', lazy_build => 1, writer => '_set_ppi' ); sub BUILD { my ($self) = @_; load_class($_) for map { $self->$_ } qw/ signature_class param_class type_constraint_class /; my $ppi = $self->ppi; # Skip leading whitespace $self->consume_token unless $ppi->significant; } sub create_param { my ($self, $args) = @_; my @traits; push @traits, $args->{ variable_name } ? 'Bindable' : 'Placeholder' if !exists $args->{unpacking}; push @traits, $args->{ named } ? 'Named' : 'Positional'; push @traits, 'Unpacked::' . $args->{unpacking} if exists $args->{unpacking}; return $self->param_class->new_with_traits(traits => \@traits, %{ $args }); } override BUILDARGS => sub { my $class = shift; return { input => $_[0] } if @_ == 1 and !ref $_[0]; return super(); }; sub parse { my ($self) = @_; my $input = substr($self->input, $self->offset); my $doc = PPI::Document->new(\$input); # Append the magic EOF Token $doc->add_element(PPI::Token::EOF->new("")); # Annoyingly "m($x)" gets treated as a regex operator. This isn't what we # want. so replace it with a Word, then a list. The way we do this is by # taking the operator off the front, then reparsing the rest of the content # This will look the same (so wont affect anything in a code block) but is # just store different token wise. $self->_replace_regexps($doc); # ($, $x) parses the $, as a single var. not what we want. FIX UP # While we're att it lets fixup $: $? and $! $self->_replace_magic($doc); # (Str :$x) yields a label of "Str :" # (Foo Bar :$x) yields a label of "Bar :" $self->_replace_labels($doc); # This one is actually a bug in PPI, rather than just an oddity # (Str $x = 0xfF) parses as "Oxf" and a word of "F" $self->_fixup_hex($doc); return $doc; } sub _replace_regexps { my ($self, $doc) = @_; REGEXP: foreach my $node ( @{ $doc->find('Token::Regexp') || [] } ) { my $str = $node->content; next REGEXP unless defined $node->{operator}; # Rather annoyingly, there are *no* methods on Token::Regexp; my ($word, $rest) = $str =~ /^(\Q@{[$node->{operator}]}\E)(.*)$/s; my $subdoc = PPI::Document->new(\$rest); my @to_add = reverse map { $_->remove } $subdoc->children; push @to_add, new PPI::Token::Word($word); # insert_after restricts what you can insert. # $node->insert_after($_) for @to_add; $node->__insert_after($_) for @to_add; $node->delete; } } sub _replace_magic { my ($self, $doc) = @_; foreach my $node ( @{ $doc->find('Token::Magic') || [] } ) { my ($op) = $node->content =~ /^\$([,?:!)])$/ or next; $node->insert_after(new PPI::Token::Operator($op)); $node->insert_after(new PPI::Token::Cast('$')); $node->delete; } } sub _replace_labels { my ($self, $doc) = @_; foreach my $node ( @{ $doc->find('Token::Label') || [] } ) { my ($word, $ws) = $node->content =~ /^(.*?)(\s+)?:$/s or next; $node->insert_after(new PPI::Token::Operator(':')); $node->insert_after(new PPI::Token::Whitespace($ws)) if defined $ws; $node->insert_after(new PPI::Token::Word($word)); $node->delete; } } sub _fixup_hex { my ($self, $doc) = @_; foreach my $node ( @{ $doc->find('Token::Number::Hex') || [] } ) { my $next = $node->next_token; next unless $next->isa('PPI::Token::Word') && $next->content =~ /^[0-9a-f]+$/i; $node->add_content($next->content); $next->delete; } } sub _build_ppi { my ($self) = @_; my $ppi = $self->ppi_doc->first_token; if ($ppi->class eq 'PPI::Token::Word' && exists $LEXTABLE{"$ppi"}) { bless $ppi, "PPI::Token::LexSymbol"; $ppi->{lex} = $LEXTABLE{"$ppi"}; } return $ppi; } # signature: O_PAREN # invocant # params # C_PAREN # # invocant: param ':' # # params: param COMMA params # | param # | /* NUL */ sub signature { my $self = shift; $self = $self->new(@_) unless blessed($self); $self->assert_token('('); my $args = {}; my $params = []; my $param = $self->param; if ($param && $self->ppi->content eq ':') { # That param was actually the invocant $args->{invocant} = $param; croak "Invocant cannot be named" if NamedParam->check($param); croak "Invocant cannot be optional" if !$param->required; croak "Invocant cannot have a default value" if $param->has_default_value; croak "Invocant must be a simple scalar" if UnpackedParam->check($param) || $param->sigil ne '$'; $self->consume_token; $param = $self->param; } if ($param) { push @$params, $param; my $greedy = $param->sigil ne '$' ? $param : undef; my $opt_pos_param = !$param->required; while ($self->ppi->content eq ',') { $self->consume_token; my $err_ctx = $self->ppi; $param = $self->param; $self->error($err_ctx, "Parameter expected") if !$param; my $is_named = NamedParam->check($param); if (!$is_named) { if ($param->required && $opt_pos_param) { $self->error($err_ctx, "Invalid: Required positional param " . " found after optional one"); } if ($greedy) { croak "Invalid: Un-named parameter '" . $param->variable_name . "' after greedy '" . $greedy->variable_name . "'\n"; } } push @$params, $param; $opt_pos_param = $opt_pos_param || !$param->required; $greedy = $param->sigil ne '$' ? $param : undef; } } $self->assert_token(')'); $args->{params} = $params; my $sig = $self->signature_class->new($args); return $sig; } # param: tc? # var # (OPTIONAL|REQUIRED)? # default? # where* # trait* # # where: WHERE # # trait: TRAIT class # # var : COLON label '(' var_or_unpack ')' # label is classish, with only /a-z0-9_/i allowed # | COLON VAR # | var_or_unpack # # var_or_unpack : '[' param* ']' # should all be required + un-named # | '{' param* '}' # Should all be named # | VAR # # OPTIONAL: '?' # REQUIRED: '!' sub param { my $self = shift; my $class_meth; unless (blessed($self)) { $self = $self->new(@_) unless blessed($self); $class_meth = 1; } # Also used to check if a anything has been consumed my $err_ctx = $self->ppi; my $param = { required => 1, }; $self->_param_typed($param); $self->_param_opt_or_req( $self->_param_labeled($param) || $self->_param_named($param) || $self->_param_variable($param) || $self->_unpacked_param($param) ) or ($err_ctx == $self->ppi and return) or $self->error($err_ctx); $self->_param_default($param); $self->_param_constraint_or_traits($param); $param = $self->create_param($param); return !$class_meth ? $param : wantarray ? ($param, $self->remaining_input) : $param; } sub _param_opt_or_req { my ($self, $param) = @_; return unless $param; if ($self->ppi->class eq 'PPI::Token::Operator') { my $c = $self->ppi->content; if ($c eq '?') { $param->{required} = 0; $self->consume_token; } elsif ($c eq '!') { $param->{required} = 1; $self->consume_token; } } return $param; } sub _param_constraint_or_traits { my ($self, $param) = @_; while ($self->_param_where($param) || $self->_param_traits($param) ) { # No op; } return $param; } sub _param_where { my ($self, $param) = @_; return unless $self->ppi->isa('PPI::Token::LexSymbol') && $self->ppi->lex eq 'WHERE'; $self->consume_token; $param->{constraints} ||= []; my $ppi = $self->ppi; $self->error($ppi, "Block expected after where") unless $ppi->class eq 'PPI::Token::Structure' && $ppi->content eq '{'; # Go from token to block $ppi = $ppi->parent; $ppi->finish or $self->error($ppi, "Runaway '" . $ppi->braces . "' in " . $self->_parsing_area(1), 1); push @{$param->{constraints}}, $ppi->content; $self->_set_ppi($ppi->finish); $self->consume_token; return $param; } sub _param_traits { my ($self, $param) = @_; return unless $self->ppi->isa('PPI::Token::LexSymbol') && $self->ppi->lex eq 'TRAIT'; my $op = $self->consume_token->content; $self->error($self->ppi, "Error parsing parameter trait") unless $self->ppi->isa('PPI::Token::Word'); $param->{param_traits} ||= []; push @{$param->{param_traits}}, [$op, $self->consume_token->content]; return $param; } sub _param_labeled { my ($self, $param) = @_; return unless $self->ppi->content eq ':' && $self->ppi->next_token->isa('PPI::Token::Word'); $self->consume_token; $self->error($self->ppi, "Invalid label") if $self->ppi->content =~ /[^-\w]/; $param->{named} = 1; $param->{required} = 0; $param->{label} = $self->consume_token->content; $self->assert_token('('); $self->_unpacked_param($param) || $self->_param_variable($param) || $self->error($self->ppi); $self->assert_token(')'); return $param; } sub _unpacked_param { my ($self, $param) = @_; return $self->bracketed('[', \&unpacked_array, $param) || $self->bracketed('{', \&unpacked_hash, $param); } sub _param_named { my ($self, $param) = @_; return unless $self->ppi->content eq ':' && $self->ppi->next_token->isa('PPI::Token::Symbol'); $param->{required} = 0; $param->{named} = 1; $self->consume_token; my $err_ctx = $self->ppi; $param = $self->_param_variable($param); $self->error($err_ctx, "Arrays or hashes cannot be named") if $param->{sigil} ne '$'; return $param; } sub _param_typed { my ($self, $param) = @_; my $tc = $self->tc or return; $tc = $self->type_constraint_class->new( ppi => $tc, ( $self->has_type_constraint_callback ? (tc_callback => $self->type_constraint_callback) : () ), ( $self->has_from_namespace ? ( from_namespace => $self->from_namespace ) : () ), ); $param->{type_constraints} = $tc; return $param; } sub _param_default { my ($self, $param) = @_; return unless $self->ppi->content eq '='; $self->consume_token; $param->{default_value} = $self->_consume_if_isa(qw/ PPI::Token::QuoteLike PPI::Token::Number PPI::Token::Quote PPI::Token::Symbol PPI::Token::Magic PPI::Token::ArrayIndex /) || $self->bracketed('[') || $self->bracketed('{') or $self->error($self->ppi); $param->{default_value} = $param->{default_value}->content; } sub _param_variable { my ($self, $param) = @_; my $ppi = $self->ppi; my $class = $ppi->class; return unless $class eq 'PPI::Token::Symbol' || $class eq 'PPI::Token::Cast'; if ($class eq 'PPI::Token::Symbol') { $ppi->symbol_type eq $ppi->raw_type or $self->error($ppi); $param->{sigil} = $ppi->raw_type; $param->{variable_name} = $self->consume_token->content; } else { $param->{sigil} = $self->consume_token->content; } return $param; } sub unpacked_hash { my ($self, $list, $param) = @_; my $params = []; while ($self->ppi->content ne '}') { my $errctx = $self->ppi; my $p = $self->param or $self->error($self->ppi); $self->error($errctx, "Cannot have positional parameters in an unpacked-array") if $p->sigil eq '$' && PositionalParam->check($p); push @$params, $p; last if $self->ppi->content eq '}'; $self->assert_token(','); } $param->{params} = $params; $param->{sigil} = '$'; $param->{unpacking} = 'Hash'; return $param; } sub unpacked_array { my ($self, $list, $param) = @_; my $params = []; while ($self->ppi->content ne ']') { my $watermark = $self->ppi; my $param = $self->param or $self->error($self->ppi); $self->error($watermark, "Cannot have named parameters in an unpacked-array") if NamedParam->check($param); $self->error($watermark, "Cannot have optional parameters in an unpacked-array") unless $param->required; push @$params, $param; last if $self->ppi->content eq ']'; $self->assert_token(','); } $param->{params} = $params; $param->{sigil} = '$'; $param->{unpacking} = 'Array'; return $param; } sub tc { my ($self, $required) = @_; my $ident = $self->_ident; $ident or ($required and $self->error($self->ppi)) or return; return $self->_tc_union( $self->bracketed('[', \&_tc_params, $ident) || $ident->clone ); } # Handle parameterized TCs. e.g.: # ArrayRef[Str] # Dict[Str => Str] # Dict["foo bar", Baz] sub _tc_params { my ($self, $list, $tc) = @_; my $new = PPI::Statement::Expression::TCParams->new($tc->clone); return $new if $self->ppi->content eq ']'; $new->add_element($self->_tc_param); while ($self->ppi->content =~ /^,|=>$/ ) { my $op = $self->consume_token; $self->_stringify_last($new) if $op->content eq '=>'; $new->add_element($self->tc(1)); } return $new; } # Valid token for individual component of parameterized TC sub _tc_param { my ($self) = @_; (my $class = $self->ppi->class) =~ s/^PPI:://; return $self->consume_token->clone if $class eq 'Token::Number' || $class =~ /^Token::Quote::(?:Single|Double|Literal|Interpolate)/; return $self->tc(1); } sub _tc_union { my ($self, $tc) = @_; return $tc unless $self->ppi->content eq '|'; my $union = PPI::Statement::Expression::TCUnion->new; $union->add_element($tc); while ( $self->ppi->content eq '|' ) { $self->consume_token; $union->add_element($self->tc(1)); } return $union; } # Stringify LHS of fat comma sub _stringify_last { my ($self, $list) = @_; my $last = $list->last_token; return unless $last->isa('PPI::Token::Word'); # Is this conditional on the content of the word? bless $last, "PPI::Token::StringifiedWord"; return $list; } # Handle the boring bits of bracketed product, then call $code->($self, ...) sub bracketed { my ($self, $type, $code, @args) = @_; local $ERROR_LEVEL = $ERROR_LEVEL + 1; my $ppi = $self->ppi; return unless $ppi->content eq $type; $self->consume_token; # consume '['; # Get from the '[' token the to Strucure::Constructor $ppi = $ppi->parent; $ppi->finish or $self->error($ppi, "Runaway '" . $ppi->braces . "' in " . $self->_parsing_area(1), 1); my $ret; if ($code) { my $list = PPI::Structure::Constructor->new($ppi->start->clone); $ret = $code->($self, $list, @args); $self->error($self->ppi) if $self->ppi != $ppi->finish; # There is no public way to do this as of PPI 1.204_06. I'll add one to the # next release, 1.205 (or so) $list->{finish} = $self->consume_token->clone; } else { # Just clone the entire [] or {} $ret = $ppi->clone; $self->_set_ppi($ppi->finish); $self->consume_token; } return $ret; } # Work out what sort of production we are in for sane default error messages sub _parsing_area { shift; my $height = shift || 0; my (undef, undef, undef, $sub) = caller($height+$ERROR_LEVEL); return "type constraint" if $sub =~ /(?:\b|_)tc(?:\b|_)/; return "unpacked parameter" if $sub =~ /(?:\b|_)unpacked(?:\b|_)/; return "parameter" if $sub =~ /(?:\b|_)param(?:\b|_)/; return "signature" if $sub =~ /(?:\b|_)signature(?:\b|_)/; " unknown production ($sub)"; } # error(PPI::Token $token, Str $msg?, Bool $no_in = 0) sub error { my ($self, $token, $msg, $no_in) = @_; $msg = "Error parsing " . $self->_parsing_area(2) unless ($msg); $msg = $msg . " near '$token'" . ($no_in ? "" : " in '" . $token->statement . "'" ); if ($DEBUG) { Carp::confess($msg); } else { Carp::croak($msg); } } sub assert_token { my ($self, $need, $msg) = @_; if ($self->ppi->content ne $need) { $self->error($self->ppi, "'$need' expected whilst parsing " . $self->_parsing_area(2)); } return $self->consume_token; } %LEXTABLE = ( where => 'WHERE', is => 'TRAIT', does => 'TRAIT', ); sub _ident { my ($self) = @_; my $ppi = $self->ppi; return $self->consume_token if $ppi->class eq 'PPI::Token::Word'; return undef; } sub _consume_if_isa { my ($self, @classes) = @_; for (@classes) { return $self->consume_token if $self->ppi->isa($_); } } sub consume_token { my ($self) = @_; my $ppi = $self->ppi; my $ret = $ppi; while (!$ppi->isa('PPI::Token::EOF') ) { $ppi = $ppi->next_token; last if $ppi->significant; } if ($ppi->class eq 'PPI::Token::Word' && exists $LEXTABLE{"$ppi"}) { bless $ppi, "PPI::Token::LexSymbol"; $ppi->{lex} = $LEXTABLE{"$ppi"}; } $self->_set_ppi( $ppi ); return $ret; } sub remaining_input { my $tok = $_[0]->ppi; my $buff; while ( !$tok->isa('PPI::Token::EOF') ) { $buff .= $tok->content; $tok = $tok->next_token; } return $buff; } __PACKAGE__->meta->make_immutable; # Extra PPI classes to represent what we want. { package PPI::Statement::Expression::TCUnion; use base 'PPI::Statement::Expression'; sub content { join('|', $_[0]->children ); } } { package PPI::Statement::Expression::TCParams; use base 'PPI::Statement::Expression'; use Moose; # $self->children stores everything so PPI can track parents # params just contains the keywords (not commas) inside the [] has type => ( is => 'ro'); has params => ( is => 'ro', default => sub { [] }, ); sub new { my ($class, $type) = @_; return $class->meta->new_object( __INSTANCE__ => $class->SUPER::new($type), type => $type ); }; override add_element => sub { my ($self, $ele) = @_; super(); push @{$self->params}, $ele; }; sub content { $_[0]->type->content . '[' . join(',', @{$_[0]->params}) . ']' } no Moose; } { package PPI::Token::LexSymbol; use base 'PPI::Token::Word'; sub lex { my ($self) = @_; return $self->{lex} } } # Used for LHS of fat comma { package PPI::Token::StringifiedWord; use base 'PPI::Token::Word'; use Moose; override content => sub { return '"' . super() . '"'; }; sub string { return $_[0]->PPI::Token::Word::content(); } no Moose; } 1; __END__ =head1 NAME Parse::Method::Signatures - Perl6 like method signature parser =head1 DESCRIPTION Inspired by L but streamlined to just support the subset deemed useful for L and L. =head1 TODO =over =item * Document the parameter return types. =item * Probably lots of other things =back =head1 METHODS There are only two public methods to this module, both of which should be called as class methods. Both methods accept either a single (non-ref) scalar as the value for the L attribute, or normal new style arguments (hash or hash-ref). =head2 signature my $sig = Parse::Method::Signatures->signature( '(Str $foo)' ) Attempts to parse the (bracketed) method signature. Returns a value or croaks on error. =head2 param my $param = Parse::Method::Signatures->param( 'Str $foo where { length($_) < 10 }') Attempts to parse the specification for a single parameter. Returns value or croaks on error. =head1 ATTRIBUTES All the attributes on this class are read-only. =head2 input B Str The string to parse. =head2 offset B Int Offset into L at which to start parsing. Useful for using with Devel::Declare linestring =head2 signature_class B Parse::Method::Signatures::Sig B Str (loaded on demand class name) =head2 param_class B Parse::Method::Signatures::Param B Str (loaded on demand class name) =head2 type_constraint_class B L B Str (loaded on demand class name) Class that is used to turn the parsed type constraint into an actual L object. =head2 from_namespace B ClassName Let this module know which package it is parsing signatures form. This is entirely optional, and the only effect is has is on parsing type constraints. If this attribute is set it is passed to L which can use it to introspect the package (commonly for L exported types). See L for more details. =head2 type_constraint_callback B CodeRef Passed to the constructor of L. Default implementation of this callback asks Moose for a type constrain matching the name passed in. If you have more complex requirements, such as parsing types created by L then you will want a callback similar to this: # my $target_package defined elsewhere. my $tc_cb = sub { my ($pms_tc, $name) = @_; my $code = $target_package->can($name); $code ? eval { $code->() } : $pms_tc->find_registered_constraint($name); } Note that the above example is better provided by providing the L attribute. =head1 CAVEATS Like Perl6::Signature, the parsing of certain constructs is currently only a 'best effort' - specifically default values and where code blocks might not successfully for certain complex cases. Patches/Failing tests welcome. Additionally, default value specifications are not evaluated which means that no such lexical or similar errors will not be produced by this module. Constant folding will also not be performed. There are certain constructs that are simply too much hassle to avoid when the work around is simple. Currently the only cases that are known to parse wrong are when using anonymous variables (i.e. just sigils) in unpacked arrays. Take the following example: method foo (ArrayRef [$, $], $some_value_we_care_about) { In this case the C<$]> is treated as one of perl's magic variables (specifically, the patch level of the Perl interpreter) rather than a C<$> followed by a C<]> as was almost certainly intended. The work around for this is simple: introduce a space between the characters: method foo (ArrayRef [ $, $ ], $some_value_we_care_about) { The same applies =head1 AUTHOR Ash Berlin . Thanks to Florian Ragwitz . Many thanks to Piers Cawley to showing me the way to refactor my spaghetti code into something more manageable. =head1 SEE ALSO L which is used by most modules that use this (currently by all modules known to the author.) L. =head1 LICENSE Licensed under the same terms as Perl itself. This distribution copyright 2008-2009, Ash Berlin Parse-Method-Signatures-1.003019/Makefile.PL0000644000175000017500000000203313067737037017032 0ustar kentkentuse lib 'inc'; use Module::Install 0.91 (); BEGIN { $INC{'inc/Module/Install.pm'} = $INC{'Module/Install.pm'}; inc::Module::Install->import } use strict; use warnings; name 'Parse-Method-Signatures'; all_from 'lib/Parse/Method/Signatures.pm'; requires 'Class::Load' => '0.19'; requires 'List::MoreUtils' => '0.20'; requires 'Moose'; requires 'MooseX::Traits' => '0.06'; requires 'MooseX::Types' => '0.17'; requires 'MooseX::Types::Moose'; requires 'MooseX::Types::Structured'; requires 'namespace::clean' => '0.10'; requires 'PPI' => '1.203'; test_requires 'aliased'; test_requires 'Test::More'; test_requires 'Test::Exception'; test_requires 'Test::Differences'; test_requires 'MooseX::Types::Structured'; postamble(<<"EOM"); testcover: pm_to_blib \tcover -delete \tHARNESS_PERL_SWITCHES=-MDevel::Cover \$(MAKE) test \tcover EOM resources( 'repository' => 'git://github.com/ashb/Parse-Method-Signatures.git', 'homepage' => 'http://github.com/ashb/Parse-Method-Signatures/tree/master', ); auto_provides; auto_install(); WriteAll; Parse-Method-Signatures-1.003019/t/0000755000175000017500000000000013072454026015313 5ustar kentkentParse-Method-Signatures-1.003019/t/signatures.t0000644000175000017500000002257613067734450017706 0ustar kentkentuse strict; use warnings; use Test::More; use Test::Exception; use Parse::Method::Signatures; my @sigs = ( ['()', 'empty signature'], ['($x)', 'single required positional'], ['($x:)', 'invocant only'], ['($x, $y)', 'two required positionals'], ['($x where { $_->isa("Moose") })', 'with constraint'], ['($x where { $_->isa("Moose") } where { $_->does("Gimble") })', 'multiple constraints'], ['(Str $name)', 'typed positional'], ['(Int $x, Str $y)', 'multiple typed positionals'], ['(Animal|Human $affe)', 'type constraint alternative'], ['(Some::Class $x)', 'type constraint with colon'], ['(Some2Class $x)', 'type constraint with number in middle'], ['(SomeClass2 $x)', 'type constraint with number at end'], ['(Tuple[Int,Str] $x)', 'parameterized types'], ['(Str|Tuple[Int,Str] $x)', 'parameterized with alternative'], ['($: $x, $y, $z)', 'dummy invocant'], ['($, $, $x)', 'dummy positionals'], ['($x, @)', 'dummy list'], ['(:$x)', 'optional named'], ['(:$x!)', 'required named'], ['(Str :$x)', 'named with type constraint'], ['($x, $y, :$z)', 'positional and named'], ['($x, $y?, :$z)', 'optional positional and named'], ['(:$a, :$b, :$c)', 'multiple named'], ['($a, $b, :$c!, :$d!)', 'positional and multiple required named'], ['($a?, $b?, :$c, :$d)', 'optional positional and named'], ['(:$x! where { 1 })', 'required named with constraint'], ['($self: $moo)', 'invocant and positional'], ['(:apan($affe))', 'long named'], # called as $obj->foo(apan => $value) ['(:apan($affe)!)', 'required long named'], ['($self: :$x)', 'named param with invocant'], ['($: :$x)', 'named param with dummy invocant'], ['($x = 42)', 'positional with default'], ['(:$x = 42)', 'named with default'], ['($x = "foo")', 'simple string default'], ['($x = "foo, bar")', 'string default with comma'], ["(\$x = 'foo, bar')", 'single quoted default with comma'], ['($x = q"foo")', 'default with q"" quoting'], ['($x = q{foo})', 'default with q{} quoting'], ['($x = q(foo))', 'default with q() quoting'], ['($x = q,foo,)', 'default with q,, quoting'], ['($x, $y = $x)', 'default based on other paramter'], ['(Str :$who, Int :$age where { $_ > 0 })', 'complex with constraint'], ['(Str $name, Bool :$excited = 0)', 'complex with default'], [q#(SomeClass $thing where { $_->can('stuff') })#, 'complex with constraint'], [q#(SomeClass $thing where { $_->can('stuff') }: Str $bar = "apan", Int :$baz = 42 where { $_ % 2 == 0 } where { $_ > 10 })#, 'complex invocant, defaults and constraints'], ['(@x)', 'positional array'], ['($x, @y)', 'positinal scalar and array'], ['(%x)', 'positinal hash'], ['($x, %y)', 'positinal scalar and hash'], ['([$x, $y])', 'simple array ref unpacking'], ['(ArrayRef [$x, $y])', 'simple array ref unpacking with unparameterized type', 'TODO'], ['(ArrayRef[] [$x, $y])', 'simple array ref unpacking with empty parameterized type',], ['([@x])', 'array ref unpacking into array'], ['([$x, $y, @rest])', 'array ref unpacking into scalars and arrays'], ['($x, [$y, $z, @rest])', 'array ref unpacking combined with normal positionals'], ['([$y, $z, @rest], $x)', 'array ref unpacking combined with normal positionals'], ['([$y, $z, @rest], :$x)', 'array ref unpacking combined with named'], ['(:foo([$x, $y, @rest]))', 'named array ref unpacking'], ['({%x})', 'hash ref unpacking into hash'], ['(:foo({%x}))', 'labeld hash ref unpacking into hash'], ['({:$x, :$y, %rest})', 'hash ref unpacking into scalars and hash'], ['($x, {:$y, :$z, %rest})', 'hash ref unpacking combined with normal positionals'], ['({:$y, :$z, %rest}, $x)', 'hash ref unpacking combined with normal positionals'], ['({:$x, :$y, %r}, :$z)', 'hash ref unpacking combined with named'], ['(:foo({:$x, :$y, %r}))', 'named hash ref unpacking'], ['(:foo($), :bar(@))', 'named placeholders'], ['(Foo[Bar|Baz[Moo]]|Kooh $foo)', 'complex parameterized type'], ['($foo is coerce)', 'positional with traits (is)'], ['($foo does coerce)', 'positional with traits (does)'], ['(:$foo is coerce)', 'named with traits (is)'], ['(:$foo does coerce)', 'named with traits (does)'], ['($foo is copy is ro does coerce)', 'multiple traits'], ['($x = "foo")', 'string default'], ['($x = q"fo)o")', 'string default'], ['($x = [ ])', 'simple array default'], ['($x = { })', 'simple hash default'], ['($x = 0xf)', 'hex default'], ['($x = 0xfF)', 'hex default'], ); my @alternative = ( [q{($param1, # Foo bar $param2?)}, '($param1, $param2?)', 'comments in multiline'], ['(:$x = "foo")', '(:$x = "foo")', 'default value stringifies okay'], ['($self: $moo)', '($self: $moo)', 'invocant and positional'], ['(Animal | Human $affe)', '(Animal|Human $affe)', 'type constraint alternative with whitespace'], ['(HashRef[foo => Str] $foo)', '(HashRef["foo",Str] $foo)', 'Hash with required key'], ); my @invalid = ( ['($x?:)', 'optional invocant'], ['(@x:)', 'non-scalar invocant'], ['(%x:)', 'non-scalar invocant'], ['($x?, $y)', 'required positional after optional one'], ['(Int| $x)', 'invalid type alternation'], ['(|Int $x)', 'invalid type alternation'], ['(@x, $y)', 'scalar after array'], ['(@x, @y)', 'multiple arrays'], ['(%x, %y)', 'multiple hashes'], ['(@, $x)', 'scalar after array placeholder'], ['(:@x)', 'named array'], ['(:%x)', 'named hash'], ['(:@)', 'named array placeholder'], ['(:%)', 'named hash placeholder'], ['(:[@x])', 'named array ref unpacking without label'], ['([:$x, :$y])', 'unpacking array ref to something not positional'], ['(:{%x})', 'named hash ref unpacking without label'], ['({$x, $y})', 'unpacking hash ref to something not named'], ['($foo where { 1, $bar)', 'unbalanced { in conditional'], ['($foo = `pwd`)', 'invalid quote op', "Do we want to allow this"], ['($foo = "pwd\')', 'unbalanced quotes'], ['(:$x:)', 'named invocant is invalid'], ['($x! = "foo":)', 'default value for invocant is invalid'], ['($foo is bar moo is bo)', 'invalid traits'], ['(Foo:: Bar $foo)', 'invalid spaces in TC'], ['(Foo ::Bar $foo)', 'invalid spaces in TC'], ['(@y: $foo)', 'invalid invocant'], ['(@y,)', 'trailing comma'], ['($x where [ foo ])', 'no block after where'], ['($x does $x)', 'invalid param trait'], ['(:foo(Str $x))', 'invalid label contents'], # This should probably be valid ['($x = $a[0])', 'invalid label contents'], ); my @no_warn = ( ['($x where { $_ =~ /foo/ })', 'Regexp without operator' ] ); plan tests => scalar @sigs * 3 + scalar @alternative + scalar @invalid + scalar @no_warn ; test_sigs(sub { my ($input, $msg, $todo) = @_; my $sig; lives_ok { $sig = Parse::Method::Signatures->signature($input); } $msg; isa_ok($sig, 'Parse::Method::Signatures::Sig', $msg); TODO: { todo_skip $todo, 1 if $todo && !$sig; is($sig->to_string, $input, $msg); } }, @sigs); for my $row (@alternative) { my ($in, $out, $msg) = @{ $row }; lives_and { is(Parse::Method::Signatures->signature($in)->to_string, $out, $msg) } $msg; } test_sigs(sub { my ($sig, $msg) = @_; dies_ok { Parse::Method::Signatures->signature($sig) } $msg; }, @invalid); test_no_warn(@no_warn); sub test_sigs { my ($test, @sigs) = @_; for my $row (@sigs) { my ($sig, $msg, $todo) = @{ $row }; TODO: { local $TODO = $todo if $todo; $test->($sig, $msg, $todo); } } } sub test_no_warn { my (@sigs) = @_; my $warnings = ""; local $SIG{__WARN__} = sub { $warnings .= "@_"; }; for my $row (@sigs) { my ($sig, $msg, $todo) = @{ $row }; TODO: { $warnings = ""; local $TODO = $todo if $todo; Parse::Method::Signatures->signature($sig); is("", $warnings, $msg || "'$sig' generated no warnings"); } } } Parse-Method-Signatures-1.003019/t/struct.t0000644000175000017500000001551713067734450017043 0ustar kentkentuse strict; use warnings; use Test::More tests => 43; use Test::Differences; use Test::Moose; use MooseX::Types::Structured qw/Dict/; use Parse::Method::Signatures; use aliased 'Parse::Method::Signatures::Param'; BEGIN { eval "use aliased 'Parse::Method::Signatures::Param::${_}'" for qw/Named Positional Bindable Placeholder/; eval "use aliased 'Parse::Method::Signatures::Param::Unpacked::${_}' => 'Unpacked${_}'" for qw/Array Hash/; } { my $sig = Parse::Method::Signatures->signature('(Str $name)'); ok(!$sig->has_named_params); ok($sig->has_positional_params); is(scalar @{ $sig->positional_params }, 1); my ($param) = $sig->positional_params; isa_ok($param, Param); ok($param->has_type_constraints); #is($param->type_constraints->data, 'Str'); is($param->variable_name, '$name'); ok($param->required); ok(!$param->has_constraints); does_ok($param, $_) for Positional, Bindable; my $tc = $param->meta_type_constraint; isa_ok($tc, 'Moose::Meta::TypeConstraint'); is($tc->name, 'Str'); } { my $sig = Parse::Method::Signatures->signature('(Str :$who, Int :$age where { $_ > 0 })'); ok(!$sig->has_positional_params); ok($sig->has_named_params); is(scalar @{ $sig->named_params }, 2); my @params = $sig->named_params; isa_ok($_, Param) for @params; for my $param (@params) { does_ok($param, $_) for Named, Bindable; } my ($who, $age) = @params; #is($who->type_constraints->data, 'Str'); is($who->variable_name, '$who'); ok(!$who->required); ok(!$who->has_constraints); my $tc = $who->meta_type_constraint; isa_ok($tc, 'Moose::Meta::TypeConstraint'); is($tc->name, 'Str'); #is($age->type_constraints->data, 'Int'); is($age->variable_name, '$age'); ok(!$age->required); ok($age->has_constraints); is_deeply([$age->constraints], ['{ $_ > 0 }']); $tc = $age->meta_type_constraint; isa_ok($tc, 'Moose::Meta::TypeConstraint'); is($tc->name, 'Int'); } { my $sig = Parse::Method::Signatures->signature('($, $foo, $)'); ok($sig->has_positional_params); ok(!$sig->has_named_params); is(scalar @{ $sig->positional_params }, 3); does_ok($sig->positional_params->[0], Placeholder); does_ok($sig->positional_params->[2], Placeholder); } { my $type = 'HashRef[ArrayRef[Moo]|Str]|Num'; my $param = Parse::Method::Signatures->param("${type} \$foo"); my $tc = $param->meta_type_constraint; isa_ok($tc, 'Moose::Meta::TypeConstraint'); is($tc->name, $type); } { my $param = Parse::Method::Signatures->param( input => 'Dict[foo => Int] $foo', type_constraint_callback => sub { my ($tc, $name) = @_; return Dict if $name eq 'Dict'; return $tc->find_registered_constraint($name); }, ); my $tc = $param->meta_type_constraint; is($tc->name, 'MooseX::Types::Structured::Dict[foo,Int]'); ok($tc->check({foo => 2}), "TC behaves right"); ok(!$tc->check({foo => "str"}), "TC behaves right"); ok(!$tc->check({Foo => "str"}), "TC behaves right"); } =for later eq_or_diff( scalar Parse::Method::Signatures->signature('(Str $name, Bool :$excited = 0)'), { params => [ { tc => 'Str', var => '$name', }, { tc => 'Bool', var => '$excited', named => 1, default => '0' }, ] }, ); eq_or_diff( scalar Parse::Method::Signatures->signature('(Animal|Human $affe)'), { params => [ { tc => 'Animal|Human', var => '$affe' }, ] }, ); eq_or_diff( scalar Parse::Method::Signatures->signature('(:$a, :$b, :$c)'), { params => [ { var => '$a', named => 1 }, { var => '$b', named => 1 }, { var => '$c', named => 1 }, ] }, ); eq_or_diff( scalar Parse::Method::Signatures->signature('( $a, $b, :$c)'), { params => [ { var => '$a' }, { var => '$b' }, { var => '$c', named => 1 }, ] }, ); eq_or_diff( scalar Parse::Method::Signatures->signature('($a , $b!, :$c!, :$d!)'), { params => [ { var => '$a' }, { var => '$b', required => 1 }, { var => '$c', named => 1, required => 1 }, { var => '$d', named => 1, required => 1 }, ] }, ); eq_or_diff( scalar Parse::Method::Signatures->signature('($a?, $b?, :$c , :$d?)'), { params => [ { var => '$a', optional => 1 }, { var => '$b', optional => 1 }, { var => '$c', named => 1, }, { var => '$d', named => 1, optional => 1 }, ] }, ); eq_or_diff( scalar Parse::Method::Signatures->signature('($self: $moo)'), { params => [ { var => '$moo' } ], invocant => { var => '$self' } }, ); # TODO: Should this have a empty invocant struct? eq_or_diff( scalar Parse::Method::Signatures->signature('(: $affe ) # called as $obj->foo(affe => $value)'), { params => [ { var => '$affe', named => 1 } ] }, ); eq_or_diff( scalar Parse::Method::Signatures->signature('(:apan($affe)) # called as $obj->foo(apan => $value)'), { params => [ { label => 'apan', var => '$affe', named => 1 } ] }, ); eq_or_diff( scalar Parse::Method::Signatures->signature(q#(SomeClass $thing where { $_->can('stuff') }: Str $bar = "apan" Int :$baz! = 42 where { $_ % 2 == 0 } where { $_ > 10 })#), { params => [ { tc => 'Str', var => '$bar', default => '"apan"' }, { tc => 'Int', var => '$baz', named => 1, required => 1, where => [ '{ $_ % 2 == 0 }', '{ $_ > 10 }' ], default => '42' } ], invocant => { tc => 'SomeClass', var => '$thing', where => [ '{ $_->can(\'stuff\') }' ] } }, ); eq_or_diff( [ Parse::Method::Signatures->signature('(Str $name)') ], [ { params => [ { tc => 'Str', var => '$name', } ] }, ''], ); eq_or_diff( [ Parse::Method::Signatures->signature('(Str $name) further data }') ], [ { params => [ { tc => 'Str', var => '$name', } ] }, 'further data }'], ); eq_or_diff( [ Parse::Method::Signatures->param( input => 'previous data(Str $name) further data }', offset => 14) ], [ { tc => 'Str', var => '$name', }, ') further data }'], ); eq_or_diff( [ Parse::Method::Signatures->param( input => 'Str $name) further data }', ) ], [ { tc => 'Str', var => '$name', }, ') further data }'], ); eq_or_diff( [ Parse::Method::Signatures->signature( "(\$param1 # Foo bar\n \$param2) postfix") ], [ { params => [ { var => '$param1' }, { var => '$param2' }, ] }, 'postfix' ] ); Parse-Method-Signatures-1.003019/t/ppi.t0000644000175000017500000001213113067734450016274 0ustar kentkentuse strict; use warnings; use Test::More 'no_plan'; use Test::Exception; use Test::Differences; use_ok("Parse::Method::Signatures") or BAIL_OUT("$@"); is( Parse::Method::Signatures->new("ArrayRef")->_ident(), "ArrayRef"); is( Parse::Method::Signatures->new("where::Foo")->_ident(), "where::Foo"); is( Parse::Method::Signatures->new("where Foo")->_ident(), undef); throws_ok { Parse::Method::Signatures->new("Foo[Bar")->tc() } qr/^\QRunaway '[]' in type constraint near '[Bar' at\E/, q/Runaway '[]' in type constraint near '[Bar' at/; throws_ok { Parse::Method::Signatures->new("Foo[Bar:]")->tc() } qr/^\QError parsing type constraint near ':' in 'Bar:' at\E/, q/Error parsing type constraint near ':' in 'Bar:' at/; is( Parse::Method::Signatures->new("ArrayRef")->tc(), "ArrayRef"); is( Parse::Method::Signatures->new("ArrayRef[Str => Str]")->tc(), 'ArrayRef["Str",Str]'); is( Parse::Method::Signatures->new("ArrayRef[Str]")->tc(), "ArrayRef[Str]"); is( Parse::Method::Signatures->new("ArrayRef[0 => Foo]")->tc(), "ArrayRef[0,Foo]"); is( Parse::Method::Signatures->new("ArrayRef[qq/0/]")->tc(), "ArrayRef[qq/0/]"); is( Parse::Method::Signatures->new("Foo|Bar")->tc(), "Foo|Bar"); lives_ok { Parse::Method::Signatures->new('$x')->param() }; throws_ok { Parse::Method::Signatures->new('$x[0]')->param() } qr/Error parsing parameter near '\$x' in '\$x\[0\]' at /, q{Error parsing parameter near '\$x' in '\$x\[0\]' at }; test_param( Parse::Method::Signatures->new('$x')->param(), { required => 1, sigil => '$', variable_name => '$x', __does => ["Parse::Method::Signatures::Param::Positional"], } ); test_param( Parse::Method::Signatures->new('$x!')->param(), { required => 1, sigil => '$', variable_name => '$x', __does => ["Parse::Method::Signatures::Param::Positional"], } ); test_param( Parse::Method::Signatures->new('$x?')->param(), { required => 0, sigil => '$', variable_name => '$x', __does => ["Parse::Method::Signatures::Param::Positional"], } ); test_param( Parse::Method::Signatures->new('@x')->param(), { required => 1, sigil => '@', variable_name => '@x', __does => ["Parse::Method::Signatures::Param::Positional"], } ); test_param( Parse::Method::Signatures->new(':$x')->param(), { required => 0, sigil => '$', variable_name => '$x', __does => ["Parse::Method::Signatures::Param::Named"], } ); # ":y($x)" is an important test, as this tests the replacment of PPI's regexp operators test_param( Parse::Method::Signatures->new(':y($x)')->param(), { required => 0, sigil => '$', variable_name => '$x', label => 'y', __does => ["Parse::Method::Signatures::Param::Named"], } ); test_param( Parse::Method::Signatures->new('$x?')->param(), { required => 0, sigil => '$', variable_name => '$x', __does => ["Parse::Method::Signatures::Param::Positional"], } ); throws_ok { Parse::Method::Signatures->new(':foo( [$x, @y?])')->param(), } qr/^Cannot have optional parameters in an unpacked-array near '\@y' in '\$x, \@y\?' at /, q/Cannot have optional parameters in an unpacked-array near '@y' in '$x, @y?' at /; throws_ok { Parse::Method::Signatures->new(':foo( [$x, :$y])')->param(), } qr/^Cannot have named parameters in an unpacked-array near ':' in '\$x, :\$y' at /, q/Cannot have named parameters in an unpacked-array near ':' in '$x, :$y' at /; throws_ok { Parse::Method::Signatures->new(':foo( [$x, :@y])')->param(), } qr/^Arrays or hashes cannot be named near '\@y' in '\$x, :\@y' at /, q/Arrays or hashes cannot be named near '@y' in '$x, :@y' at /; throws_ok { Parse::Method::Signatures->new(':foo( {$x, :@y])')->param(), } qr/^Runaway '\{\}' in unpacked parameter near '\{\$x, :\@y' at /, q/Runaway '{}' in unpacked parameter near '{$x, :@y' at /; test_param( my $param = Parse::Method::Signatures->new(':foo( {:$x, @y})')->param(), { label => 'foo', sigil => '$', required => 0, __does => ['Parse::Method::Signatures::Param::Unpacked::Hash'], } ); throws_ok { Parse::Method::Signatures->new('($x = 0xfG)')->signature(), } qr/^'\)' expected whilst parsing signature near 'G' in '\$x = 0xfG' at/, q/')' expected whilst paring signautre near 'G' in '$x = 0xfG' at/; test_param( $param->params->[0], { required => 0, sigil => '$', variable_name => '$x' } ); test_param( $param->params->[1], { required => 1, sigil => '@', variable_name => '@y' } ); #test_param( # Parse::Method::Signatures->new(':foo( [$x, @y?])')->param(), # { required => 1, # sigil => '$', # variable_name => '$x', # label => 'y', # __does => ["Parse::Method::Signatures::Param::Named"], # } #); sub test_param { my ($param, $wanted, $msg) = @_; local $Test::Builder::Level = 2; if (my $isa = delete $wanted->{__isa}) { isa_ok($param, $isa, $msg) or diag("@{[$param->meta->linearized_isa]}"); } for ( @{ delete $wanted->{__does} || [] }) { ok(0 , "Param doesn't do $_" ) && last unless $param->does($_) } my $p = { %$param }; delete $p->{_trait_namespace}; delete $p->{_params}; delete $p->{__MOP__}; eq_or_diff($p, $wanted, $msg); } Parse-Method-Signatures-1.003019/inc/0000755000175000017500000000000013072454026015621 5ustar kentkentParse-Method-Signatures-1.003019/inc/Module/0000755000175000017500000000000013072454026017046 5ustar kentkentParse-Method-Signatures-1.003019/inc/Module/AutoInstall.pm0000644000175000017500000006231113072454011021640 0ustar kentkent#line 1 package Module::AutoInstall; use strict; use Cwd (); use File::Spec (); use ExtUtils::MakeMaker (); use vars qw{$VERSION}; BEGIN { $VERSION = '1.17'; } # special map on pre-defined feature sets my %FeatureMap = ( '' => 'Core Features', # XXX: deprecated '-core' => 'Core Features', ); # various lexical flags my ( @Missing, @Existing, %DisabledTests, $UnderCPAN, $InstallDepsTarget, $HasCPANPLUS ); my ( $Config, $CheckOnly, $SkipInstall, $AcceptDefault, $TestOnly, $AllDeps, $UpgradeDeps ); my ( $PostambleActions, $PostambleActionsNoTest, $PostambleActionsUpgradeDeps, $PostambleActionsUpgradeDepsNoTest, $PostambleActionsListDeps, $PostambleActionsListAllDeps, $PostambleUsed, $NoTest); # See if it's a testing or non-interactive session _accept_default( $ENV{AUTOMATED_TESTING} or ! -t STDIN ); _init(); sub _accept_default { $AcceptDefault = shift; } sub _installdeps_target { $InstallDepsTarget = shift; } sub missing_modules { return @Missing; } sub do_install { __PACKAGE__->install( [ $Config ? ( UNIVERSAL::isa( $Config, 'HASH' ) ? %{$Config} : @{$Config} ) : () ], @Missing, ); } # initialize various flags, and/or perform install sub _init { foreach my $arg ( @ARGV, split( /[\s\t]+/, $ENV{PERL_AUTOINSTALL} || $ENV{PERL_EXTUTILS_AUTOINSTALL} || '' ) ) { if ( $arg =~ /^--config=(.*)$/ ) { $Config = [ split( ',', $1 ) ]; } elsif ( $arg =~ /^--installdeps=(.*)$/ ) { __PACKAGE__->install( $Config, @Missing = split( /,/, $1 ) ); exit 0; } elsif ( $arg =~ /^--upgradedeps=(.*)$/ ) { $UpgradeDeps = 1; __PACKAGE__->install( $Config, @Missing = split( /,/, $1 ) ); exit 0; } elsif ( $arg =~ /^--default(?:deps)?$/ ) { $AcceptDefault = 1; } elsif ( $arg =~ /^--check(?:deps)?$/ ) { $CheckOnly = 1; } elsif ( $arg =~ /^--skip(?:deps)?$/ ) { $SkipInstall = 1; } elsif ( $arg =~ /^--test(?:only)?$/ ) { $TestOnly = 1; } elsif ( $arg =~ /^--all(?:deps)?$/ ) { $AllDeps = 1; } } } # overrides MakeMaker's prompt() to automatically accept the default choice sub _prompt { goto &ExtUtils::MakeMaker::prompt unless $AcceptDefault; my ( $prompt, $default ) = @_; my $y = ( $default =~ /^[Yy]/ ); print $prompt, ' [', ( $y ? 'Y' : 'y' ), '/', ( $y ? 'n' : 'N' ), '] '; print "$default\n"; return $default; } # the workhorse sub import { my $class = shift; my @args = @_ or return; my $core_all; print "*** $class version " . $class->VERSION . "\n"; print "*** Checking for Perl dependencies...\n"; my $cwd = Cwd::getcwd(); $Config = []; my $maxlen = length( ( sort { length($b) <=> length($a) } grep { /^[^\-]/ } map { ref($_) ? ( ( ref($_) eq 'HASH' ) ? keys(%$_) : @{$_} ) : '' } map { +{@args}->{$_} } grep { /^[^\-]/ or /^-core$/i } keys %{ +{@args} } )[0] ); # We want to know if we're under CPAN early to avoid prompting, but # if we aren't going to try and install anything anyway then skip the # check entirely since we don't want to have to load (and configure) # an old CPAN just for a cosmetic message $UnderCPAN = _check_lock(1) unless $SkipInstall || $InstallDepsTarget; while ( my ( $feature, $modules ) = splice( @args, 0, 2 ) ) { my ( @required, @tests, @skiptests ); my $default = 1; my $conflict = 0; if ( $feature =~ m/^-(\w+)$/ ) { my $option = lc($1); # check for a newer version of myself _update_to( $modules, @_ ) and return if $option eq 'version'; # sets CPAN configuration options $Config = $modules if $option eq 'config'; # promote every features to core status $core_all = ( $modules =~ /^all$/i ) and next if $option eq 'core'; next unless $option eq 'core'; } print "[" . ( $FeatureMap{ lc($feature) } || $feature ) . "]\n"; $modules = [ %{$modules} ] if UNIVERSAL::isa( $modules, 'HASH' ); unshift @$modules, -default => &{ shift(@$modules) } if ( ref( $modules->[0] ) eq 'CODE' ); # XXX: bugward compatibility while ( my ( $mod, $arg ) = splice( @$modules, 0, 2 ) ) { if ( $mod =~ m/^-(\w+)$/ ) { my $option = lc($1); $default = $arg if ( $option eq 'default' ); $conflict = $arg if ( $option eq 'conflict' ); @tests = @{$arg} if ( $option eq 'tests' ); @skiptests = @{$arg} if ( $option eq 'skiptests' ); next; } printf( "- %-${maxlen}s ...", $mod ); if ( $arg and $arg =~ /^\D/ ) { unshift @$modules, $arg; $arg = 0; } # XXX: check for conflicts and uninstalls(!) them. my $cur = _version_of($mod); if (_version_cmp ($cur, $arg) >= 0) { print "loaded. ($cur" . ( $arg ? " >= $arg" : '' ) . ")\n"; push @Existing, $mod => $arg; $DisabledTests{$_} = 1 for map { glob($_) } @skiptests; } else { if (not defined $cur) # indeed missing { print "missing." . ( $arg ? " (would need $arg)" : '' ) . "\n"; } else { # no need to check $arg as _version_cmp ($cur, undef) would satisfy >= above print "too old. ($cur < $arg)\n"; } push @required, $mod => $arg; } } next unless @required; my $mandatory = ( $feature eq '-core' or $core_all ); if ( !$SkipInstall and ( $CheckOnly or ($mandatory and $UnderCPAN) or $AllDeps or $InstallDepsTarget or _prompt( qq{==> Auto-install the } . ( @required / 2 ) . ( $mandatory ? ' mandatory' : ' optional' ) . qq{ module(s) from CPAN?}, $default ? 'y' : 'n', ) =~ /^[Yy]/ ) ) { push( @Missing, @required ); $DisabledTests{$_} = 1 for map { glob($_) } @skiptests; } elsif ( !$SkipInstall and $default and $mandatory and _prompt( qq{==> The module(s) are mandatory! Really skip?}, 'n', ) =~ /^[Nn]/ ) { push( @Missing, @required ); $DisabledTests{$_} = 1 for map { glob($_) } @skiptests; } else { $DisabledTests{$_} = 1 for map { glob($_) } @tests; } } if ( @Missing and not( $CheckOnly or $UnderCPAN) ) { require Config; my $make = $Config::Config{make}; if ($InstallDepsTarget) { print "*** To install dependencies type '$make installdeps' or '$make installdeps_notest'.\n"; } else { print "*** Dependencies will be installed the next time you type '$make'.\n"; } # make an educated guess of whether we'll need root permission. print " (You may need to do that as the 'root' user.)\n" if eval '$>'; } print "*** $class configuration finished.\n"; chdir $cwd; # import to main:: no strict 'refs'; *{'main::WriteMakefile'} = \&Write if caller(0) eq 'main'; return (@Existing, @Missing); } sub _running_under { my $thing = shift; print <<"END_MESSAGE"; *** Since we're running under ${thing}, I'll just let it take care of the dependency's installation later. END_MESSAGE return 1; } # Check to see if we are currently running under CPAN.pm and/or CPANPLUS; # if we are, then we simply let it taking care of our dependencies sub _check_lock { return unless @Missing or @_; if ($ENV{PERL5_CPANM_IS_RUNNING}) { return _running_under('cpanminus'); } my $cpan_env = $ENV{PERL5_CPAN_IS_RUNNING}; if ($ENV{PERL5_CPANPLUS_IS_RUNNING}) { return _running_under($cpan_env ? 'CPAN' : 'CPANPLUS'); } require CPAN; if ($CPAN::VERSION > '1.89') { if ($cpan_env) { return _running_under('CPAN'); } return; # CPAN.pm new enough, don't need to check further } # last ditch attempt, this -will- configure CPAN, very sorry _load_cpan(1); # force initialize even though it's already loaded # Find the CPAN lock-file my $lock = MM->catfile( $CPAN::Config->{cpan_home}, ".lock" ); return unless -f $lock; # Check the lock local *LOCK; return unless open(LOCK, $lock); if ( ( $^O eq 'MSWin32' ? _under_cpan() : == getppid() ) and ( $CPAN::Config->{prerequisites_policy} || '' ) ne 'ignore' ) { print <<'END_MESSAGE'; *** Since we're running under CPAN, I'll just let it take care of the dependency's installation later. END_MESSAGE return 1; } close LOCK; return; } sub install { my $class = shift; my $i; # used below to strip leading '-' from config keys my @config = ( map { s/^-// if ++$i; $_ } @{ +shift } ); my ( @modules, @installed, @modules_to_upgrade ); while (my ($pkg, $ver) = splice(@_, 0, 2)) { # grep out those already installed if (_version_cmp(_version_of($pkg), $ver) >= 0) { push @installed, $pkg; if ($UpgradeDeps) { push @modules_to_upgrade, $pkg, $ver; } } else { push @modules, $pkg, $ver; } } if ($UpgradeDeps) { push @modules, @modules_to_upgrade; @installed = (); @modules_to_upgrade = (); } return @installed unless @modules; # nothing to do return @installed if _check_lock(); # defer to the CPAN shell print "*** Installing dependencies...\n"; return unless _connected_to('cpan.org'); my %args = @config; my %failed; local *FAILED; if ( $args{do_once} and open( FAILED, '.#autoinstall.failed' ) ) { while () { chomp; $failed{$_}++ } close FAILED; my @newmod; while ( my ( $k, $v ) = splice( @modules, 0, 2 ) ) { push @newmod, ( $k => $v ) unless $failed{$k}; } @modules = @newmod; } if ( _has_cpanplus() and not $ENV{PERL_AUTOINSTALL_PREFER_CPAN} ) { _install_cpanplus( \@modules, \@config ); } else { _install_cpan( \@modules, \@config ); } print "*** $class installation finished.\n"; # see if we have successfully installed them while ( my ( $pkg, $ver ) = splice( @modules, 0, 2 ) ) { if ( _version_cmp( _version_of($pkg), $ver ) >= 0 ) { push @installed, $pkg; } elsif ( $args{do_once} and open( FAILED, '>> .#autoinstall.failed' ) ) { print FAILED "$pkg\n"; } } close FAILED if $args{do_once}; return @installed; } sub _install_cpanplus { my @modules = @{ +shift }; my @config = _cpanplus_config( @{ +shift } ); my $installed = 0; require CPANPLUS::Backend; my $cp = CPANPLUS::Backend->new; my $conf = $cp->configure_object; return unless $conf->can('conf') # 0.05x+ with "sudo" support or _can_write($conf->_get_build('base')); # 0.04x # if we're root, set UNINST=1 to avoid trouble unless user asked for it. my $makeflags = $conf->get_conf('makeflags') || ''; if ( UNIVERSAL::isa( $makeflags, 'HASH' ) ) { # 0.03+ uses a hashref here $makeflags->{UNINST} = 1 unless exists $makeflags->{UNINST}; } else { # 0.02 and below uses a scalar $makeflags = join( ' ', split( ' ', $makeflags ), 'UNINST=1' ) if ( $makeflags !~ /\bUNINST\b/ and eval qq{ $> eq '0' } ); } $conf->set_conf( makeflags => $makeflags ); $conf->set_conf( prereqs => 1 ); while ( my ( $key, $val ) = splice( @config, 0, 2 ) ) { $conf->set_conf( $key, $val ); } my $modtree = $cp->module_tree; while ( my ( $pkg, $ver ) = splice( @modules, 0, 2 ) ) { print "*** Installing $pkg...\n"; MY::preinstall( $pkg, $ver ) or next if defined &MY::preinstall; my $success; my $obj = $modtree->{$pkg}; if ( $obj and _version_cmp( $obj->{version}, $ver ) >= 0 ) { my $pathname = $pkg; $pathname =~ s/::/\\W/; foreach my $inc ( grep { m/$pathname.pm/i } keys(%INC) ) { delete $INC{$inc}; } my $rv = $cp->install( modules => [ $obj->{module} ] ); if ( $rv and ( $rv->{ $obj->{module} } or $rv->{ok} ) ) { print "*** $pkg successfully installed.\n"; $success = 1; } else { print "*** $pkg installation cancelled.\n"; $success = 0; } $installed += $success; } else { print << "."; *** Could not find a version $ver or above for $pkg; skipping. . } MY::postinstall( $pkg, $ver, $success ) if defined &MY::postinstall; } return $installed; } sub _cpanplus_config { my @config = (); while ( @_ ) { my ($key, $value) = (shift(), shift()); if ( $key eq 'prerequisites_policy' ) { if ( $value eq 'follow' ) { $value = CPANPLUS::Internals::Constants::PREREQ_INSTALL(); } elsif ( $value eq 'ask' ) { $value = CPANPLUS::Internals::Constants::PREREQ_ASK(); } elsif ( $value eq 'ignore' ) { $value = CPANPLUS::Internals::Constants::PREREQ_IGNORE(); } else { die "*** Cannot convert option $key = '$value' to CPANPLUS version.\n"; } push @config, 'prereqs', $value; } elsif ( $key eq 'force' ) { push @config, $key, $value; } elsif ( $key eq 'notest' ) { push @config, 'skiptest', $value; } else { die "*** Cannot convert option $key to CPANPLUS version.\n"; } } return @config; } sub _install_cpan { my @modules = @{ +shift }; my @config = @{ +shift }; my $installed = 0; my %args; _load_cpan(); require Config; if (CPAN->VERSION < 1.80) { # no "sudo" support, probe for writableness return unless _can_write( MM->catfile( $CPAN::Config->{cpan_home}, 'sources' ) ) and _can_write( $Config::Config{sitelib} ); } # if we're root, set UNINST=1 to avoid trouble unless user asked for it. my $makeflags = $CPAN::Config->{make_install_arg} || ''; $CPAN::Config->{make_install_arg} = join( ' ', split( ' ', $makeflags ), 'UNINST=1' ) if ( $makeflags !~ /\bUNINST\b/ and eval qq{ $> eq '0' } ); # don't show start-up info $CPAN::Config->{inhibit_startup_message} = 1; # set additional options while ( my ( $opt, $arg ) = splice( @config, 0, 2 ) ) { ( $args{$opt} = $arg, next ) if $opt =~ /^(?:force|notest)$/; # pseudo-option $CPAN::Config->{$opt} = $opt eq 'urllist' ? [$arg] : $arg; } if ($args{notest} && (not CPAN::Shell->can('notest'))) { die "Your version of CPAN is too old to support the 'notest' pragma"; } local $CPAN::Config->{prerequisites_policy} = 'follow'; while ( my ( $pkg, $ver ) = splice( @modules, 0, 2 ) ) { MY::preinstall( $pkg, $ver ) or next if defined &MY::preinstall; print "*** Installing $pkg...\n"; my $obj = CPAN::Shell->expand( Module => $pkg ); my $success = 0; if ( $obj and _version_cmp( $obj->cpan_version, $ver ) >= 0 ) { my $pathname = $pkg; $pathname =~ s/::/\\W/; foreach my $inc ( grep { m/$pathname.pm/i } keys(%INC) ) { delete $INC{$inc}; } my $rv = do { if ($args{force}) { CPAN::Shell->force( install => $pkg ) } elsif ($args{notest}) { CPAN::Shell->notest( install => $pkg ) } else { CPAN::Shell->install($pkg) } }; $rv ||= eval { $CPAN::META->instance( 'CPAN::Distribution', $obj->cpan_file, ) ->{install} if $CPAN::META; }; if ( $rv eq 'YES' ) { print "*** $pkg successfully installed.\n"; $success = 1; } else { print "*** $pkg installation failed.\n"; $success = 0; } $installed += $success; } else { print << "."; *** Could not find a version $ver or above for $pkg; skipping. . } MY::postinstall( $pkg, $ver, $success ) if defined &MY::postinstall; } return $installed; } sub _has_cpanplus { return ( $HasCPANPLUS = ( $INC{'CPANPLUS/Config.pm'} or _load('CPANPLUS::Shell::Default') ) ); } # make guesses on whether we're under the CPAN installation directory sub _under_cpan { require Cwd; require File::Spec; my $cwd = File::Spec->canonpath( Cwd::getcwd() ); my $cpan = File::Spec->canonpath( $CPAN::Config->{cpan_home} ); return ( index( $cwd, $cpan ) > -1 ); } sub _update_to { my $class = __PACKAGE__; my $ver = shift; return if _version_cmp( _version_of($class), $ver ) >= 0; # no need to upgrade if ( _prompt( "==> A newer version of $class ($ver) is required. Install?", 'y' ) =~ /^[Nn]/ ) { die "*** Please install $class $ver manually.\n"; } print << "."; *** Trying to fetch it from CPAN... . # install ourselves _load($class) and return $class->import(@_) if $class->install( [], $class, $ver ); print << '.'; exit 1; *** Cannot bootstrap myself. :-( Installation terminated. . } # check if we're connected to some host, using inet_aton sub _connected_to { my $site = shift; return ( ( _load('Socket') and Socket::inet_aton($site) ) or _prompt( qq( *** Your host cannot resolve the domain name '$site', which probably means the Internet connections are unavailable. ==> Should we try to install the required module(s) anyway?), 'n' ) =~ /^[Yy]/ ); } # check if a directory is writable; may create it on demand sub _can_write { my $path = shift; mkdir( $path, 0755 ) unless -e $path; return 1 if -w $path; print << "."; *** You are not allowed to write to the directory '$path'; the installation may fail due to insufficient permissions. . if ( eval '$>' and lc(`sudo -V`) =~ /version/ and _prompt( qq( ==> Should we try to re-execute the autoinstall process with 'sudo'?), ((-t STDIN) ? 'y' : 'n') ) =~ /^[Yy]/ ) { # try to bootstrap ourselves from sudo print << "."; *** Trying to re-execute the autoinstall process with 'sudo'... . my $missing = join( ',', @Missing ); my $config = join( ',', UNIVERSAL::isa( $Config, 'HASH' ) ? %{$Config} : @{$Config} ) if $Config; return unless system( 'sudo', $^X, $0, "--config=$config", "--installdeps=$missing" ); print << "."; *** The 'sudo' command exited with error! Resuming... . } return _prompt( qq( ==> Should we try to install the required module(s) anyway?), 'n' ) =~ /^[Yy]/; } # load a module and return the version it reports sub _load { my $mod = pop; # method/function doesn't matter my $file = $mod; $file =~ s|::|/|g; $file .= '.pm'; local $@; return eval { require $file; $mod->VERSION } || ( $@ ? undef: 0 ); } # report version without loading a module sub _version_of { my $mod = pop; # method/function doesn't matter my $file = $mod; $file =~ s|::|/|g; $file .= '.pm'; foreach my $dir ( @INC ) { next if ref $dir; my $path = File::Spec->catfile($dir, $file); next unless -e $path; require ExtUtils::MM_Unix; return ExtUtils::MM_Unix->parse_version($path); } return undef; } # Load CPAN.pm and it's configuration sub _load_cpan { return if $CPAN::VERSION and $CPAN::Config and not @_; require CPAN; # CPAN-1.82+ adds CPAN::Config::AUTOLOAD to redirect to # CPAN::HandleConfig->load. CPAN reports that the redirection # is deprecated in a warning printed at the user. # CPAN-1.81 expects CPAN::HandleConfig->load, does not have # $CPAN::HandleConfig::VERSION but cannot handle # CPAN::Config->load # Which "versions expect CPAN::Config->load? if ( $CPAN::HandleConfig::VERSION || CPAN::HandleConfig->can('load') ) { # Newer versions of CPAN have a HandleConfig module CPAN::HandleConfig->load; } else { # Older versions had the load method in Config directly CPAN::Config->load; } } # compare two versions, either use Sort::Versions or plain comparison # return values same as <=> sub _version_cmp { my ( $cur, $min ) = @_; return -1 unless defined $cur; # if 0 keep comparing return 1 unless $min; $cur =~ s/\s+$//; # check for version numbers that are not in decimal format if ( ref($cur) or ref($min) or $cur =~ /v|\..*\./ or $min =~ /v|\..*\./ ) { if ( ( $version::VERSION or defined( _load('version') )) and version->can('new') ) { # use version.pm if it is installed. return version->new($cur) <=> version->new($min); } elsif ( $Sort::Versions::VERSION or defined( _load('Sort::Versions') ) ) { # use Sort::Versions as the sorting algorithm for a.b.c versions return Sort::Versions::versioncmp( $cur, $min ); } warn "Cannot reliably compare non-decimal formatted versions.\n" . "Please install version.pm or Sort::Versions.\n"; } # plain comparison local $^W = 0; # shuts off 'not numeric' bugs return $cur <=> $min; } # nothing; this usage is deprecated. sub main::PREREQ_PM { return {}; } sub _make_args { my %args = @_; $args{PREREQ_PM} = { %{ $args{PREREQ_PM} || {} }, @Existing, @Missing } if $UnderCPAN or $TestOnly; if ( $args{EXE_FILES} and -e 'MANIFEST' ) { require ExtUtils::Manifest; my $manifest = ExtUtils::Manifest::maniread('MANIFEST'); $args{EXE_FILES} = [ grep { exists $manifest->{$_} } @{ $args{EXE_FILES} } ]; } $args{test}{TESTS} ||= 't/*.t'; $args{test}{TESTS} = join( ' ', grep { !exists( $DisabledTests{$_} ) } map { glob($_) } split( /\s+/, $args{test}{TESTS} ) ); my $missing = join( ',', @Missing ); my $config = join( ',', UNIVERSAL::isa( $Config, 'HASH' ) ? %{$Config} : @{$Config} ) if $Config; $PostambleActions = ( ($missing and not $UnderCPAN) ? "\$(PERL) $0 --config=$config --installdeps=$missing" : "\$(NOECHO) \$(NOOP)" ); my $deps_list = join( ',', @Missing, @Existing ); $PostambleActionsUpgradeDeps = "\$(PERL) $0 --config=$config --upgradedeps=$deps_list"; my $config_notest = join( ',', (UNIVERSAL::isa( $Config, 'HASH' ) ? %{$Config} : @{$Config}), 'notest', 1 ) if $Config; $PostambleActionsNoTest = ( ($missing and not $UnderCPAN) ? "\$(PERL) $0 --config=$config_notest --installdeps=$missing" : "\$(NOECHO) \$(NOOP)" ); $PostambleActionsUpgradeDepsNoTest = "\$(PERL) $0 --config=$config_notest --upgradedeps=$deps_list"; $PostambleActionsListDeps = '@$(PERL) -le "print for @ARGV" ' . join(' ', map $Missing[$_], grep $_ % 2 == 0, 0..$#Missing); my @all = (@Missing, @Existing); $PostambleActionsListAllDeps = '@$(PERL) -le "print for @ARGV" ' . join(' ', map $all[$_], grep $_ % 2 == 0, 0..$#all); return %args; } # a wrapper to ExtUtils::MakeMaker::WriteMakefile sub Write { require Carp; Carp::croak "WriteMakefile: Need even number of args" if @_ % 2; if ($CheckOnly) { print << "."; *** Makefile not written in check-only mode. . return; } my %args = _make_args(@_); no strict 'refs'; $PostambleUsed = 0; local *MY::postamble = \&postamble unless defined &MY::postamble; ExtUtils::MakeMaker::WriteMakefile(%args); print << "." unless $PostambleUsed; *** WARNING: Makefile written with customized MY::postamble() without including contents from Module::AutoInstall::postamble() -- auto installation features disabled. Please contact the author. . return 1; } sub postamble { $PostambleUsed = 1; my $fragment; $fragment .= <<"AUTO_INSTALL" if !$InstallDepsTarget; config :: installdeps \t\$(NOECHO) \$(NOOP) AUTO_INSTALL $fragment .= <<"END_MAKE"; checkdeps :: \t\$(PERL) $0 --checkdeps installdeps :: \t$PostambleActions installdeps_notest :: \t$PostambleActionsNoTest upgradedeps :: \t$PostambleActionsUpgradeDeps upgradedeps_notest :: \t$PostambleActionsUpgradeDepsNoTest listdeps :: \t$PostambleActionsListDeps listalldeps :: \t$PostambleActionsListAllDeps END_MAKE return $fragment; } 1; __END__ #line 1197 Parse-Method-Signatures-1.003019/inc/Module/Install.pm0000644000175000017500000002714513072454011021015 0ustar kentkent#line 1 package Module::Install; # For any maintainers: # The load order for Module::Install is a bit magic. # It goes something like this... # # IF ( host has Module::Install installed, creating author mode ) { # 1. Makefile.PL calls "use inc::Module::Install" # 2. $INC{inc/Module/Install.pm} set to installed version of inc::Module::Install # 3. The installed version of inc::Module::Install loads # 4. inc::Module::Install calls "require Module::Install" # 5. The ./inc/ version of Module::Install loads # } ELSE { # 1. Makefile.PL calls "use inc::Module::Install" # 2. $INC{inc/Module/Install.pm} set to ./inc/ version of Module::Install # 3. The ./inc/ version of Module::Install loads # } use 5.006; use strict 'vars'; use Cwd (); use File::Find (); use File::Path (); use vars qw{$VERSION $MAIN}; BEGIN { # All Module::Install core packages now require synchronised versions. # This will be used to ensure we don't accidentally load old or # different versions of modules. # This is not enforced yet, but will be some time in the next few # releases once we can make sure it won't clash with custom # Module::Install extensions. $VERSION = '1.17'; # Storage for the pseudo-singleton $MAIN = undef; *inc::Module::Install::VERSION = *VERSION; @inc::Module::Install::ISA = __PACKAGE__; } sub import { my $class = shift; my $self = $class->new(@_); my $who = $self->_caller; #------------------------------------------------------------- # all of the following checks should be included in import(), # to allow "eval 'require Module::Install; 1' to test # installation of Module::Install. (RT #51267) #------------------------------------------------------------- # Whether or not inc::Module::Install is actually loaded, the # $INC{inc/Module/Install.pm} is what will still get set as long as # the caller loaded module this in the documented manner. # If not set, the caller may NOT have loaded the bundled version, and thus # they may not have a MI version that works with the Makefile.PL. This would # result in false errors or unexpected behaviour. And we don't want that. my $file = join( '/', 'inc', split /::/, __PACKAGE__ ) . '.pm'; unless ( $INC{$file} ) { die <<"END_DIE" } Please invoke ${\__PACKAGE__} with: use inc::${\__PACKAGE__}; not: use ${\__PACKAGE__}; END_DIE # This reportedly fixes a rare Win32 UTC file time issue, but # as this is a non-cross-platform XS module not in the core, # we shouldn't really depend on it. See RT #24194 for detail. # (Also, this module only supports Perl 5.6 and above). eval "use Win32::UTCFileTime" if $^O eq 'MSWin32' && $] >= 5.006; # If the script that is loading Module::Install is from the future, # then make will detect this and cause it to re-run over and over # again. This is bad. Rather than taking action to touch it (which # is unreliable on some platforms and requires write permissions) # for now we should catch this and refuse to run. if ( -f $0 ) { my $s = (stat($0))[9]; # If the modification time is only slightly in the future, # sleep briefly to remove the problem. my $a = $s - time; if ( $a > 0 and $a < 5 ) { sleep 5 } # Too far in the future, throw an error. my $t = time; if ( $s > $t ) { die <<"END_DIE" } Your installer $0 has a modification time in the future ($s > $t). This is known to create infinite loops in make. Please correct this, then run $0 again. END_DIE } # Build.PL was formerly supported, but no longer is due to excessive # difficulty in implementing every single feature twice. if ( $0 =~ /Build.PL$/i ) { die <<"END_DIE" } Module::Install no longer supports Build.PL. It was impossible to maintain duel backends, and has been deprecated. Please remove all Build.PL files and only use the Makefile.PL installer. END_DIE #------------------------------------------------------------- # To save some more typing in Module::Install installers, every... # use inc::Module::Install # ...also acts as an implicit use strict. $^H |= strict::bits(qw(refs subs vars)); #------------------------------------------------------------- unless ( -f $self->{file} ) { foreach my $key (keys %INC) { delete $INC{$key} if $key =~ /Module\/Install/; } local $^W; require "$self->{path}/$self->{dispatch}.pm"; File::Path::mkpath("$self->{prefix}/$self->{author}"); $self->{admin} = "$self->{name}::$self->{dispatch}"->new( _top => $self ); $self->{admin}->init; @_ = ($class, _self => $self); goto &{"$self->{name}::import"}; } local $^W; *{"${who}::AUTOLOAD"} = $self->autoload; $self->preload; # Unregister loader and worker packages so subdirs can use them again delete $INC{'inc/Module/Install.pm'}; delete $INC{'Module/Install.pm'}; # Save to the singleton $MAIN = $self; return 1; } sub autoload { my $self = shift; my $who = $self->_caller; my $cwd = Cwd::getcwd(); my $sym = "${who}::AUTOLOAD"; $sym->{$cwd} = sub { my $pwd = Cwd::getcwd(); if ( my $code = $sym->{$pwd} ) { # Delegate back to parent dirs goto &$code unless $cwd eq $pwd; } unless ($$sym =~ s/([^:]+)$//) { # XXX: it looks like we can't retrieve the missing function # via $$sym (usually $main::AUTOLOAD) in this case. # I'm still wondering if we should slurp Makefile.PL to # get some context or not ... my ($package, $file, $line) = caller; die <<"EOT"; Unknown function is found at $file line $line. Execution of $file aborted due to runtime errors. If you're a contributor to a project, you may need to install some Module::Install extensions from CPAN (or other repository). If you're a user of a module, please contact the author. EOT } my $method = $1; if ( uc($method) eq $method ) { # Do nothing return; } elsif ( $method =~ /^_/ and $self->can($method) ) { # Dispatch to the root M:I class return $self->$method(@_); } # Dispatch to the appropriate plugin unshift @_, ( $self, $1 ); goto &{$self->can('call')}; }; } sub preload { my $self = shift; unless ( $self->{extensions} ) { $self->load_extensions( "$self->{prefix}/$self->{path}", $self ); } my @exts = @{$self->{extensions}}; unless ( @exts ) { @exts = $self->{admin}->load_all_extensions; } my %seen; foreach my $obj ( @exts ) { while (my ($method, $glob) = each %{ref($obj) . '::'}) { next unless $obj->can($method); next if $method =~ /^_/; next if $method eq uc($method); $seen{$method}++; } } my $who = $self->_caller; foreach my $name ( sort keys %seen ) { local $^W; *{"${who}::$name"} = sub { ${"${who}::AUTOLOAD"} = "${who}::$name"; goto &{"${who}::AUTOLOAD"}; }; } } sub new { my ($class, %args) = @_; delete $INC{'FindBin.pm'}; { # to suppress the redefine warning local $SIG{__WARN__} = sub {}; require FindBin; } # ignore the prefix on extension modules built from top level. my $base_path = Cwd::abs_path($FindBin::Bin); unless ( Cwd::abs_path(Cwd::getcwd()) eq $base_path ) { delete $args{prefix}; } return $args{_self} if $args{_self}; $base_path = VMS::Filespec::unixify($base_path) if $^O eq 'VMS'; $args{dispatch} ||= 'Admin'; $args{prefix} ||= 'inc'; $args{author} ||= ($^O eq 'VMS' ? '_author' : '.author'); $args{bundle} ||= 'inc/BUNDLES'; $args{base} ||= $base_path; $class =~ s/^\Q$args{prefix}\E:://; $args{name} ||= $class; $args{version} ||= $class->VERSION; unless ( $args{path} ) { $args{path} = $args{name}; $args{path} =~ s!::!/!g; } $args{file} ||= "$args{base}/$args{prefix}/$args{path}.pm"; $args{wrote} = 0; bless( \%args, $class ); } sub call { my ($self, $method) = @_; my $obj = $self->load($method) or return; splice(@_, 0, 2, $obj); goto &{$obj->can($method)}; } sub load { my ($self, $method) = @_; $self->load_extensions( "$self->{prefix}/$self->{path}", $self ) unless $self->{extensions}; foreach my $obj (@{$self->{extensions}}) { return $obj if $obj->can($method); } my $admin = $self->{admin} or die <<"END_DIE"; The '$method' method does not exist in the '$self->{prefix}' path! Please remove the '$self->{prefix}' directory and run $0 again to load it. END_DIE my $obj = $admin->load($method, 1); push @{$self->{extensions}}, $obj; $obj; } sub load_extensions { my ($self, $path, $top) = @_; my $should_reload = 0; unless ( grep { ! ref $_ and lc $_ eq lc $self->{prefix} } @INC ) { unshift @INC, $self->{prefix}; $should_reload = 1; } foreach my $rv ( $self->find_extensions($path) ) { my ($file, $pkg) = @{$rv}; next if $self->{pathnames}{$pkg}; local $@; my $new = eval { local $^W; require $file; $pkg->can('new') }; unless ( $new ) { warn $@ if $@; next; } $self->{pathnames}{$pkg} = $should_reload ? delete $INC{$file} : $INC{$file}; push @{$self->{extensions}}, &{$new}($pkg, _top => $top ); } $self->{extensions} ||= []; } sub find_extensions { my ($self, $path) = @_; my @found; File::Find::find( {no_chdir => 1, wanted => sub { my $file = $File::Find::name; return unless $file =~ m!^\Q$path\E/(.+)\.pm\Z!is; my $subpath = $1; return if lc($subpath) eq lc($self->{dispatch}); $file = "$self->{path}/$subpath.pm"; my $pkg = "$self->{name}::$subpath"; $pkg =~ s!/!::!g; # If we have a mixed-case package name, assume case has been preserved # correctly. Otherwise, root through the file to locate the case-preserved # version of the package name. if ( $subpath eq lc($subpath) || $subpath eq uc($subpath) ) { my $content = Module::Install::_read($File::Find::name); my $in_pod = 0; foreach ( split /\n/, $content ) { $in_pod = 1 if /^=\w/; $in_pod = 0 if /^=cut/; next if ($in_pod || /^=cut/); # skip pod text next if /^\s*#/; # and comments if ( m/^\s*package\s+($pkg)\s*;/i ) { $pkg = $1; last; } } } push @found, [ $file, $pkg ]; }}, $path ) if -d $path; @found; } ##################################################################### # Common Utility Functions sub _caller { my $depth = 0; my $call = caller($depth); while ( $call eq __PACKAGE__ ) { $depth++; $call = caller($depth); } return $call; } sub _read { local *FH; open( FH, '<', $_[0] ) or die "open($_[0]): $!"; binmode FH; my $string = do { local $/; }; close FH or die "close($_[0]): $!"; return $string; } sub _readperl { my $string = Module::Install::_read($_[0]); $string =~ s/(?:\015{1,2}\012|\015|\012)/\n/sg; $string =~ s/(\n)\n*__(?:DATA|END)__\b.*\z/$1/s; $string =~ s/\n\n=\w+.+?\n\n=cut\b.+?\n+/\n\n/sg; return $string; } sub _readpod { my $string = Module::Install::_read($_[0]); $string =~ s/(?:\015{1,2}\012|\015|\012)/\n/sg; return $string if $_[0] =~ /\.pod\z/; $string =~ s/(^|\n=cut\b.+?\n+)[^=\s].+?\n(\n=\w+|\z)/$1$2/sg; $string =~ s/\n*=pod\b[^\n]*\n+/\n\n/sg; $string =~ s/\n*=cut\b[^\n]*\n+/\n\n/sg; $string =~ s/^\n+//s; return $string; } sub _write { local *FH; open( FH, '>', $_[0] ) or die "open($_[0]): $!"; binmode FH; foreach ( 1 .. $#_ ) { print FH $_[$_] or die "print($_[0]): $!"; } close FH or die "close($_[0]): $!"; } # _version is for processing module versions (eg, 1.03_05) not # Perl versions (eg, 5.8.1). sub _version { my $s = shift || 0; my $d =()= $s =~ /(\.)/g; if ( $d >= 2 ) { # Normalise multipart versions $s =~ s/(\.)(\d{1,3})/sprintf("$1%03d",$2)/eg; } $s =~ s/^(\d+)\.?//; my $l = $1 || 0; my @v = map { $_ . '0' x (3 - length $_) } $s =~ /(\d{1,3})\D?/g; $l = $l . '.' . join '', @v if @v; return $l + 0; } sub _cmp { _version($_[1]) <=> _version($_[2]); } # Cloned from Params::Util::_CLASS sub _CLASS { ( defined $_[0] and ! ref $_[0] and $_[0] =~ m/^[^\W\d]\w*(?:::\w+)*\z/s ) ? $_[0] : undef; } 1; # Copyright 2008 - 2012 Adam Kennedy. Parse-Method-Signatures-1.003019/inc/Module/Install/0000755000175000017500000000000013072454026020454 5ustar kentkentParse-Method-Signatures-1.003019/inc/Module/Install/Metadata.pm0000644000175000017500000004330213072454011022526 0ustar kentkent#line 1 package Module::Install::Metadata; use strict 'vars'; use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '1.17'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } my @boolean_keys = qw{ sign }; my @scalar_keys = qw{ name module_name abstract version distribution_type tests installdirs }; my @tuple_keys = qw{ configure_requires build_requires requires recommends bundles resources }; my @resource_keys = qw{ homepage bugtracker repository }; my @array_keys = qw{ keywords author }; *authors = \&author; sub Meta { shift } sub Meta_BooleanKeys { @boolean_keys } sub Meta_ScalarKeys { @scalar_keys } sub Meta_TupleKeys { @tuple_keys } sub Meta_ResourceKeys { @resource_keys } sub Meta_ArrayKeys { @array_keys } foreach my $key ( @boolean_keys ) { *$key = sub { my $self = shift; if ( defined wantarray and not @_ ) { return $self->{values}->{$key}; } $self->{values}->{$key} = ( @_ ? $_[0] : 1 ); return $self; }; } foreach my $key ( @scalar_keys ) { *$key = sub { my $self = shift; return $self->{values}->{$key} if defined wantarray and !@_; $self->{values}->{$key} = shift; return $self; }; } foreach my $key ( @array_keys ) { *$key = sub { my $self = shift; return $self->{values}->{$key} if defined wantarray and !@_; $self->{values}->{$key} ||= []; push @{$self->{values}->{$key}}, @_; return $self; }; } foreach my $key ( @resource_keys ) { *$key = sub { my $self = shift; unless ( @_ ) { return () unless $self->{values}->{resources}; return map { $_->[1] } grep { $_->[0] eq $key } @{ $self->{values}->{resources} }; } return $self->{values}->{resources}->{$key} unless @_; my $uri = shift or die( "Did not provide a value to $key()" ); $self->resources( $key => $uri ); return 1; }; } foreach my $key ( grep { $_ ne "resources" } @tuple_keys) { *$key = sub { my $self = shift; return $self->{values}->{$key} unless @_; my @added; while ( @_ ) { my $module = shift or last; my $version = shift || 0; push @added, [ $module, $version ]; } push @{ $self->{values}->{$key} }, @added; return map {@$_} @added; }; } # Resource handling my %lc_resource = map { $_ => 1 } qw{ homepage license bugtracker repository }; sub resources { my $self = shift; while ( @_ ) { my $name = shift or last; my $value = shift or next; if ( $name eq lc $name and ! $lc_resource{$name} ) { die("Unsupported reserved lowercase resource '$name'"); } $self->{values}->{resources} ||= []; push @{ $self->{values}->{resources} }, [ $name, $value ]; } $self->{values}->{resources}; } # Aliases for build_requires that will have alternative # meanings in some future version of META.yml. sub test_requires { shift->build_requires(@_) } sub install_requires { shift->build_requires(@_) } # Aliases for installdirs options sub install_as_core { $_[0]->installdirs('perl') } sub install_as_cpan { $_[0]->installdirs('site') } sub install_as_site { $_[0]->installdirs('site') } sub install_as_vendor { $_[0]->installdirs('vendor') } sub dynamic_config { my $self = shift; my $value = @_ ? shift : 1; if ( $self->{values}->{dynamic_config} ) { # Once dynamic we never change to static, for safety return 0; } $self->{values}->{dynamic_config} = $value ? 1 : 0; return 1; } # Convenience command sub static_config { shift->dynamic_config(0); } sub perl_version { my $self = shift; return $self->{values}->{perl_version} unless @_; my $version = shift or die( "Did not provide a value to perl_version()" ); # Normalize the version $version = $self->_perl_version($version); # We don't support the really old versions unless ( $version >= 5.005 ) { die "Module::Install only supports 5.005 or newer (use ExtUtils::MakeMaker)\n"; } $self->{values}->{perl_version} = $version; } sub all_from { my ( $self, $file ) = @_; unless ( defined($file) ) { my $name = $self->name or die( "all_from called with no args without setting name() first" ); $file = join('/', 'lib', split(/-/, $name)) . '.pm'; $file =~ s{.*/}{} unless -e $file; unless ( -e $file ) { die("all_from cannot find $file from $name"); } } unless ( -f $file ) { die("The path '$file' does not exist, or is not a file"); } $self->{values}{all_from} = $file; # Some methods pull from POD instead of code. # If there is a matching .pod, use that instead my $pod = $file; $pod =~ s/\.pm$/.pod/i; $pod = $file unless -e $pod; # Pull the different values $self->name_from($file) unless $self->name; $self->version_from($file) unless $self->version; $self->perl_version_from($file) unless $self->perl_version; $self->author_from($pod) unless @{$self->author || []}; $self->license_from($pod) unless $self->license; $self->abstract_from($pod) unless $self->abstract; return 1; } sub provides { my $self = shift; my $provides = ( $self->{values}->{provides} ||= {} ); %$provides = (%$provides, @_) if @_; return $provides; } sub auto_provides { my $self = shift; return $self unless $self->is_admin; unless (-e 'MANIFEST') { warn "Cannot deduce auto_provides without a MANIFEST, skipping\n"; return $self; } # Avoid spurious warnings as we are not checking manifest here. local $SIG{__WARN__} = sub {1}; require ExtUtils::Manifest; local *ExtUtils::Manifest::manicheck = sub { return }; require Module::Build; my $build = Module::Build->new( dist_name => $self->name, dist_version => $self->version, license => $self->license, ); $self->provides( %{ $build->find_dist_packages || {} } ); } sub feature { my $self = shift; my $name = shift; my $features = ( $self->{values}->{features} ||= [] ); my $mods; if ( @_ == 1 and ref( $_[0] ) ) { # The user used ->feature like ->features by passing in the second # argument as a reference. Accomodate for that. $mods = $_[0]; } else { $mods = \@_; } my $count = 0; push @$features, ( $name => [ map { ref($_) ? ( ref($_) eq 'HASH' ) ? %$_ : @$_ : $_ } @$mods ] ); return @$features; } sub features { my $self = shift; while ( my ( $name, $mods ) = splice( @_, 0, 2 ) ) { $self->feature( $name, @$mods ); } return $self->{values}->{features} ? @{ $self->{values}->{features} } : (); } sub no_index { my $self = shift; my $type = shift; push @{ $self->{values}->{no_index}->{$type} }, @_ if $type; return $self->{values}->{no_index}; } sub read { my $self = shift; $self->include_deps( 'YAML::Tiny', 0 ); require YAML::Tiny; my $data = YAML::Tiny::LoadFile('META.yml'); # Call methods explicitly in case user has already set some values. while ( my ( $key, $value ) = each %$data ) { next unless $self->can($key); if ( ref $value eq 'HASH' ) { while ( my ( $module, $version ) = each %$value ) { $self->can($key)->($self, $module => $version ); } } else { $self->can($key)->($self, $value); } } return $self; } sub write { my $self = shift; return $self unless $self->is_admin; $self->admin->write_meta; return $self; } sub version_from { require ExtUtils::MM_Unix; my ( $self, $file ) = @_; $self->version( ExtUtils::MM_Unix->parse_version($file) ); # for version integrity check $self->makemaker_args( VERSION_FROM => $file ); } sub abstract_from { require ExtUtils::MM_Unix; my ( $self, $file ) = @_; $self->abstract( bless( { DISTNAME => $self->name }, 'ExtUtils::MM_Unix' )->parse_abstract($file) ); } # Add both distribution and module name sub name_from { my ($self, $file) = @_; if ( Module::Install::_read($file) =~ m/ ^ \s* package \s* ([\w:]+) [\s|;]* /ixms ) { my ($name, $module_name) = ($1, $1); $name =~ s{::}{-}g; $self->name($name); unless ( $self->module_name ) { $self->module_name($module_name); } } else { die("Cannot determine name from $file\n"); } } sub _extract_perl_version { if ( $_[0] =~ m/ ^\s* (?:use|require) \s* v? ([\d_\.]+) \s* ; /ixms ) { my $perl_version = $1; $perl_version =~ s{_}{}g; return $perl_version; } else { return; } } sub perl_version_from { my $self = shift; my $perl_version=_extract_perl_version(Module::Install::_read($_[0])); if ($perl_version) { $self->perl_version($perl_version); } else { warn "Cannot determine perl version info from $_[0]\n"; return; } } sub author_from { my $self = shift; my $content = Module::Install::_read($_[0]); if ($content =~ m/ =head \d \s+ (?:authors?)\b \s* ([^\n]*) | =head \d \s+ (?:licen[cs]e|licensing|copyright|legal)\b \s* .*? copyright .*? \d\d\d[\d.]+ \s* (?:\bby\b)? \s* ([^\n]*) /ixms) { my $author = $1 || $2; # XXX: ugly but should work anyway... if (eval "require Pod::Escapes; 1") { # Pod::Escapes has a mapping table. # It's in core of perl >= 5.9.3, and should be installed # as one of the Pod::Simple's prereqs, which is a prereq # of Pod::Text 3.x (see also below). $author =~ s{ E<( (\d+) | ([A-Za-z]+) )> } { defined $2 ? chr($2) : defined $Pod::Escapes::Name2character_number{$1} ? chr($Pod::Escapes::Name2character_number{$1}) : do { warn "Unknown escape: E<$1>"; "E<$1>"; }; }gex; } elsif (eval "require Pod::Text; 1" && $Pod::Text::VERSION < 3) { # Pod::Text < 3.0 has yet another mapping table, # though the table name of 2.x and 1.x are different. # (1.x is in core of Perl < 5.6, 2.x is in core of # Perl < 5.9.3) my $mapping = ($Pod::Text::VERSION < 2) ? \%Pod::Text::HTML_Escapes : \%Pod::Text::ESCAPES; $author =~ s{ E<( (\d+) | ([A-Za-z]+) )> } { defined $2 ? chr($2) : defined $mapping->{$1} ? $mapping->{$1} : do { warn "Unknown escape: E<$1>"; "E<$1>"; }; }gex; } else { $author =~ s{E}{<}g; $author =~ s{E}{>}g; } $self->author($author); } else { warn "Cannot determine author info from $_[0]\n"; } } #Stolen from M::B my %license_urls = ( perl => 'http://dev.perl.org/licenses/', apache => 'http://apache.org/licenses/LICENSE-2.0', apache_1_1 => 'http://apache.org/licenses/LICENSE-1.1', artistic => 'http://opensource.org/licenses/artistic-license.php', artistic_2 => 'http://opensource.org/licenses/artistic-license-2.0.php', lgpl => 'http://opensource.org/licenses/lgpl-license.php', lgpl2 => 'http://opensource.org/licenses/lgpl-2.1.php', lgpl3 => 'http://opensource.org/licenses/lgpl-3.0.html', bsd => 'http://opensource.org/licenses/bsd-license.php', gpl => 'http://opensource.org/licenses/gpl-license.php', gpl2 => 'http://opensource.org/licenses/gpl-2.0.php', gpl3 => 'http://opensource.org/licenses/gpl-3.0.html', mit => 'http://opensource.org/licenses/mit-license.php', mozilla => 'http://opensource.org/licenses/mozilla1.1.php', open_source => undef, unrestricted => undef, restrictive => undef, unknown => undef, ); sub license { my $self = shift; return $self->{values}->{license} unless @_; my $license = shift or die( 'Did not provide a value to license()' ); $license = __extract_license($license) || lc $license; $self->{values}->{license} = $license; # Automatically fill in license URLs if ( $license_urls{$license} ) { $self->resources( license => $license_urls{$license} ); } return 1; } sub _extract_license { my $pod = shift; my $matched; return __extract_license( ($matched) = $pod =~ m/ (=head \d \s+ L(?i:ICEN[CS]E|ICENSING)\b.*?) (=head \d.*|=cut.*|)\z /xms ) || __extract_license( ($matched) = $pod =~ m/ (=head \d \s+ (?:C(?i:OPYRIGHTS?)|L(?i:EGAL))\b.*?) (=head \d.*|=cut.*|)\z /xms ); } sub __extract_license { my $license_text = shift or return; my @phrases = ( '(?:under )?the same (?:terms|license) as (?:perl|the perl (?:\d )?programming language)' => 'perl', 1, '(?:under )?the terms of (?:perl|the perl programming language) itself' => 'perl', 1, 'Artistic and GPL' => 'perl', 1, 'GNU general public license' => 'gpl', 1, 'GNU public license' => 'gpl', 1, 'GNU lesser general public license' => 'lgpl', 1, 'GNU lesser public license' => 'lgpl', 1, 'GNU library general public license' => 'lgpl', 1, 'GNU library public license' => 'lgpl', 1, 'GNU Free Documentation license' => 'unrestricted', 1, 'GNU Affero General Public License' => 'open_source', 1, '(?:Free)?BSD license' => 'bsd', 1, 'Artistic license 2\.0' => 'artistic_2', 1, 'Artistic license' => 'artistic', 1, 'Apache (?:Software )?license' => 'apache', 1, 'GPL' => 'gpl', 1, 'LGPL' => 'lgpl', 1, 'BSD' => 'bsd', 1, 'Artistic' => 'artistic', 1, 'MIT' => 'mit', 1, 'Mozilla Public License' => 'mozilla', 1, 'Q Public License' => 'open_source', 1, 'OpenSSL License' => 'unrestricted', 1, 'SSLeay License' => 'unrestricted', 1, 'zlib License' => 'open_source', 1, 'proprietary' => 'proprietary', 0, ); while ( my ($pattern, $license, $osi) = splice(@phrases, 0, 3) ) { $pattern =~ s#\s+#\\s+#gs; if ( $license_text =~ /\b$pattern\b/i ) { return $license; } } return ''; } sub license_from { my $self = shift; if (my $license=_extract_license(Module::Install::_read($_[0]))) { $self->license($license); } else { warn "Cannot determine license info from $_[0]\n"; return 'unknown'; } } sub _extract_bugtracker { my @links = $_[0] =~ m#L<( https?\Q://rt.cpan.org/\E[^>]+| https?\Q://github.com/\E[\w_]+/[\w_]+/issues| https?\Q://code.google.com/p/\E[\w_\-]+/issues/list )>#gx; my %links; @links{@links}=(); @links=keys %links; return @links; } sub bugtracker_from { my $self = shift; my $content = Module::Install::_read($_[0]); my @links = _extract_bugtracker($content); unless ( @links ) { warn "Cannot determine bugtracker info from $_[0]\n"; return 0; } if ( @links > 1 ) { warn "Found more than one bugtracker link in $_[0]\n"; return 0; } # Set the bugtracker bugtracker( $links[0] ); return 1; } sub requires_from { my $self = shift; my $content = Module::Install::_readperl($_[0]); my @requires = $content =~ m/^use\s+([^\W\d]\w*(?:::\w+)*)\s+(v?[\d\.]+)/mg; while ( @requires ) { my $module = shift @requires; my $version = shift @requires; $self->requires( $module => $version ); } } sub test_requires_from { my $self = shift; my $content = Module::Install::_readperl($_[0]); my @requires = $content =~ m/^use\s+([^\W\d]\w*(?:::\w+)*)\s+([\d\.]+)/mg; while ( @requires ) { my $module = shift @requires; my $version = shift @requires; $self->test_requires( $module => $version ); } } # Convert triple-part versions (eg, 5.6.1 or 5.8.9) to # numbers (eg, 5.006001 or 5.008009). # Also, convert double-part versions (eg, 5.8) sub _perl_version { my $v = $_[-1]; $v =~ s/^([1-9])\.([1-9]\d?\d?)$/sprintf("%d.%03d",$1,$2)/e; $v =~ s/^([1-9])\.([1-9]\d?\d?)\.(0|[1-9]\d?\d?)$/sprintf("%d.%03d%03d",$1,$2,$3 || 0)/e; $v =~ s/(\.\d\d\d)000$/$1/; $v =~ s/_.+$//; if ( ref($v) ) { # Numify $v = $v + 0; } return $v; } sub add_metadata { my $self = shift; my %hash = @_; for my $key (keys %hash) { warn "add_metadata: $key is not prefixed with 'x_'.\n" . "Use appopriate function to add non-private metadata.\n" unless $key =~ /^x_/; $self->{values}->{$key} = $hash{$key}; } } ###################################################################### # MYMETA Support sub WriteMyMeta { die "WriteMyMeta has been deprecated"; } sub write_mymeta_yaml { my $self = shift; # We need YAML::Tiny to write the MYMETA.yml file unless ( eval { require YAML::Tiny; 1; } ) { return 1; } # Generate the data my $meta = $self->_write_mymeta_data or return 1; # Save as the MYMETA.yml file print "Writing MYMETA.yml\n"; YAML::Tiny::DumpFile('MYMETA.yml', $meta); } sub write_mymeta_json { my $self = shift; # We need JSON to write the MYMETA.json file unless ( eval { require JSON; 1; } ) { return 1; } # Generate the data my $meta = $self->_write_mymeta_data or return 1; # Save as the MYMETA.yml file print "Writing MYMETA.json\n"; Module::Install::_write( 'MYMETA.json', JSON->new->pretty(1)->canonical->encode($meta), ); } sub _write_mymeta_data { my $self = shift; # If there's no existing META.yml there is nothing we can do return undef unless -f 'META.yml'; # We need Parse::CPAN::Meta to load the file unless ( eval { require Parse::CPAN::Meta; 1; } ) { return undef; } # Merge the perl version into the dependencies my $val = $self->Meta->{values}; my $perl = delete $val->{perl_version}; if ( $perl ) { $val->{requires} ||= []; my $requires = $val->{requires}; # Canonize to three-dot version after Perl 5.6 if ( $perl >= 5.006 ) { $perl =~ s{^(\d+)\.(\d\d\d)(\d*)}{join('.', $1, int($2||0), int($3||0))}e } unshift @$requires, [ perl => $perl ]; } # Load the advisory META.yml file my @yaml = Parse::CPAN::Meta::LoadFile('META.yml'); my $meta = $yaml[0]; # Overwrite the non-configure dependency hashes delete $meta->{requires}; delete $meta->{build_requires}; delete $meta->{recommends}; if ( exists $val->{requires} ) { $meta->{requires} = { map { @$_ } @{ $val->{requires} } }; } if ( exists $val->{build_requires} ) { $meta->{build_requires} = { map { @$_ } @{ $val->{build_requires} } }; } return $meta; } 1; Parse-Method-Signatures-1.003019/inc/Module/Install/Win32.pm0000644000175000017500000000340313072454012021707 0ustar kentkent#line 1 package Module::Install::Win32; use strict; use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '1.17'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } # determine if the user needs nmake, and download it if needed sub check_nmake { my $self = shift; $self->load('can_run'); $self->load('get_file'); require Config; return unless ( $^O eq 'MSWin32' and $Config::Config{make} and $Config::Config{make} =~ /^nmake\b/i and ! $self->can_run('nmake') ); print "The required 'nmake' executable not found, fetching it...\n"; require File::Basename; my $rv = $self->get_file( url => 'http://download.microsoft.com/download/vc15/Patch/1.52/W95/EN-US/Nmake15.exe', ftp_url => 'ftp://ftp.microsoft.com/Softlib/MSLFILES/Nmake15.exe', local_dir => File::Basename::dirname($^X), size => 51928, run => 'Nmake15.exe /o > nul', check_for => 'Nmake.exe', remove => 1, ); die <<'END_MESSAGE' unless $rv; ------------------------------------------------------------------------------- Since you are using Microsoft Windows, you will need the 'nmake' utility before installation. It's available at: http://download.microsoft.com/download/vc15/Patch/1.52/W95/EN-US/Nmake15.exe or ftp://ftp.microsoft.com/Softlib/MSLFILES/Nmake15.exe Please download the file manually, save it to a directory in %PATH% (e.g. C:\WINDOWS\COMMAND\), then launch the MS-DOS command line shell, "cd" to that directory, and run "Nmake15.exe" from there; that will create the 'nmake.exe' file needed by this module. You may then resume the installation process described in README. ------------------------------------------------------------------------------- END_MESSAGE } 1; Parse-Method-Signatures-1.003019/inc/Module/Install/AutoInstall.pm0000644000175000017500000000416213072454011023246 0ustar kentkent#line 1 package Module::Install::AutoInstall; use strict; use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '1.17'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } sub AutoInstall { $_[0] } sub run { my $self = shift; $self->auto_install_now(@_); } sub write { my $self = shift; $self->auto_install(@_); } sub auto_install { my $self = shift; return if $self->{done}++; # Flatten array of arrays into a single array my @core = map @$_, map @$_, grep ref, $self->build_requires, $self->requires; my @config = @_; # We'll need Module::AutoInstall $self->include('Module::AutoInstall'); require Module::AutoInstall; my @features_require = Module::AutoInstall->import( (@config ? (-config => \@config) : ()), (@core ? (-core => \@core) : ()), $self->features, ); my %seen; my @requires = map @$_, map @$_, grep ref, $self->requires; while (my ($mod, $ver) = splice(@requires, 0, 2)) { $seen{$mod}{$ver}++; } my @build_requires = map @$_, map @$_, grep ref, $self->build_requires; while (my ($mod, $ver) = splice(@build_requires, 0, 2)) { $seen{$mod}{$ver}++; } my @configure_requires = map @$_, map @$_, grep ref, $self->configure_requires; while (my ($mod, $ver) = splice(@configure_requires, 0, 2)) { $seen{$mod}{$ver}++; } my @deduped; while (my ($mod, $ver) = splice(@features_require, 0, 2)) { push @deduped, $mod => $ver unless $seen{$mod}{$ver}++; } $self->requires(@deduped); $self->makemaker_args( Module::AutoInstall::_make_args() ); my $class = ref($self); $self->postamble( "# --- $class section:\n" . Module::AutoInstall::postamble() ); } sub installdeps_target { my ($self, @args) = @_; $self->include('Module::AutoInstall'); require Module::AutoInstall; Module::AutoInstall::_installdeps_target(1); $self->auto_install(@args); } sub auto_install_now { my $self = shift; $self->auto_install(@_); Module::AutoInstall::do_install(); } 1; Parse-Method-Signatures-1.003019/inc/Module/Install/Include.pm0000644000175000017500000000101513072454011022364 0ustar kentkent#line 1 package Module::Install::Include; use strict; use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '1.17'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } sub include { shift()->admin->include(@_); } sub include_deps { shift()->admin->include_deps(@_); } sub auto_include { shift()->admin->auto_include(@_); } sub auto_include_deps { shift()->admin->auto_include_deps(@_); } sub auto_include_dependent_dists { shift()->admin->auto_include_dependent_dists(@_); } 1; Parse-Method-Signatures-1.003019/inc/Module/Install/WriteAll.pm0000644000175000017500000000237613072454012022540 0ustar kentkent#line 1 package Module::Install::WriteAll; use strict; use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '1.17'; @ISA = qw{Module::Install::Base}; $ISCORE = 1; } sub WriteAll { my $self = shift; my %args = ( meta => 1, sign => 0, inline => 0, check_nmake => 1, @_, ); $self->sign(1) if $args{sign}; $self->admin->WriteAll(%args) if $self->is_admin; $self->check_nmake if $args{check_nmake}; unless ( $self->makemaker_args->{PL_FILES} ) { # XXX: This still may be a bit over-defensive... unless ($self->makemaker(6.25)) { $self->makemaker_args( PL_FILES => {} ) if -f 'Build.PL'; } } # Until ExtUtils::MakeMaker support MYMETA.yml, make sure # we clean it up properly ourself. $self->realclean_files('MYMETA.yml'); if ( $args{inline} ) { $self->Inline->write; } else { $self->Makefile->write; } # The Makefile write process adds a couple of dependencies, # so write the META.yml files after the Makefile. if ( $args{meta} ) { $self->Meta->write; } # Experimental support for MYMETA if ( $ENV{X_MYMETA} ) { if ( $ENV{X_MYMETA} eq 'JSON' ) { $self->Meta->write_mymeta_json; } else { $self->Meta->write_mymeta_yaml; } } return 1; } 1; Parse-Method-Signatures-1.003019/inc/Module/Install/Base.pm0000644000175000017500000000214713072454011021662 0ustar kentkent#line 1 package Module::Install::Base; use strict 'vars'; use vars qw{$VERSION}; BEGIN { $VERSION = '1.17'; } # Suspend handler for "redefined" warnings BEGIN { my $w = $SIG{__WARN__}; $SIG{__WARN__} = sub { $w }; } #line 42 sub new { my $class = shift; unless ( defined &{"${class}::call"} ) { *{"${class}::call"} = sub { shift->_top->call(@_) }; } unless ( defined &{"${class}::load"} ) { *{"${class}::load"} = sub { shift->_top->load(@_) }; } bless { @_ }, $class; } #line 61 sub AUTOLOAD { local $@; my $func = eval { shift->_top->autoload } or return; goto &$func; } #line 75 sub _top { $_[0]->{_top}; } #line 90 sub admin { $_[0]->_top->{admin} or Module::Install::Base::FakeAdmin->new; } #line 106 sub is_admin { ! $_[0]->admin->isa('Module::Install::Base::FakeAdmin'); } sub DESTROY {} package Module::Install::Base::FakeAdmin; use vars qw{$VERSION}; BEGIN { $VERSION = $Module::Install::Base::VERSION; } my $fake; sub new { $fake ||= bless(\@_, $_[0]); } sub AUTOLOAD {} sub DESTROY {} # Restore warning handler BEGIN { $SIG{__WARN__} = $SIG{__WARN__}->(); } 1; #line 159 Parse-Method-Signatures-1.003019/inc/Module/Install/Can.pm0000644000175000017500000000640513072454012021513 0ustar kentkent#line 1 package Module::Install::Can; use strict; use Config (); use ExtUtils::MakeMaker (); use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '1.17'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } # check if we can load some module ### Upgrade this to not have to load the module if possible sub can_use { my ($self, $mod, $ver) = @_; $mod =~ s{::|\\}{/}g; $mod .= '.pm' unless $mod =~ /\.pm$/i; my $pkg = $mod; $pkg =~ s{/}{::}g; $pkg =~ s{\.pm$}{}i; local $@; eval { require $mod; $pkg->VERSION($ver || 0); 1 }; } # Check if we can run some command sub can_run { my ($self, $cmd) = @_; my $_cmd = $cmd; return $_cmd if (-x $_cmd or $_cmd = MM->maybe_command($_cmd)); for my $dir ((split /$Config::Config{path_sep}/, $ENV{PATH}), '.') { next if $dir eq ''; require File::Spec; my $abs = File::Spec->catfile($dir, $cmd); return $abs if (-x $abs or $abs = MM->maybe_command($abs)); } return; } # Can our C compiler environment build XS files sub can_xs { my $self = shift; # Ensure we have the CBuilder module $self->configure_requires( 'ExtUtils::CBuilder' => 0.27 ); # Do we have the configure_requires checker? local $@; eval "require ExtUtils::CBuilder;"; if ( $@ ) { # They don't obey configure_requires, so it is # someone old and delicate. Try to avoid hurting # them by falling back to an older simpler test. return $self->can_cc(); } # Do we have a working C compiler my $builder = ExtUtils::CBuilder->new( quiet => 1, ); unless ( $builder->have_compiler ) { # No working C compiler return 0; } # Write a C file representative of what XS becomes require File::Temp; my ( $FH, $tmpfile ) = File::Temp::tempfile( "compilexs-XXXXX", SUFFIX => '.c', ); binmode $FH; print $FH <<'END_C'; #include "EXTERN.h" #include "perl.h" #include "XSUB.h" int main(int argc, char **argv) { return 0; } int boot_sanexs() { return 1; } END_C close $FH; # Can the C compiler access the same headers XS does my @libs = (); my $object = undef; eval { local $^W = 0; $object = $builder->compile( source => $tmpfile, ); @libs = $builder->link( objects => $object, module_name => 'sanexs', ); }; my $result = $@ ? 0 : 1; # Clean up all the build files foreach ( $tmpfile, $object, @libs ) { next unless defined $_; 1 while unlink; } return $result; } # Can we locate a (the) C compiler sub can_cc { my $self = shift; if ($^O eq 'VMS') { require ExtUtils::CBuilder; my $builder = ExtUtils::CBuilder->new( quiet => 1, ); return $builder->have_compiler; } my @chunks = split(/ /, $Config::Config{cc}) or return; # $Config{cc} may contain args; try to find out the program part while (@chunks) { return $self->can_run("@chunks") || (pop(@chunks), next); } return; } # Fix Cygwin bug on maybe_command(); if ( $^O eq 'cygwin' ) { require ExtUtils::MM_Cygwin; require ExtUtils::MM_Win32; if ( ! defined(&ExtUtils::MM_Cygwin::maybe_command) ) { *ExtUtils::MM_Cygwin::maybe_command = sub { my ($self, $file) = @_; if ($file =~ m{^/cygdrive/}i and ExtUtils::MM_Win32->can('maybe_command')) { ExtUtils::MM_Win32->maybe_command($file); } else { ExtUtils::MM_Unix->maybe_command($file); } } } } 1; __END__ #line 245 Parse-Method-Signatures-1.003019/inc/Module/Install/Makefile.pm0000644000175000017500000002743713072454011022536 0ustar kentkent#line 1 package Module::Install::Makefile; use strict 'vars'; use ExtUtils::MakeMaker (); use Module::Install::Base (); use Fcntl qw/:flock :seek/; use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '1.17'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } sub Makefile { $_[0] } my %seen = (); sub prompt { shift; # Infinite loop protection my @c = caller(); if ( ++$seen{"$c[1]|$c[2]|$_[0]"} > 3 ) { die "Caught an potential prompt infinite loop ($c[1]|$c[2]|$_[0])"; } # In automated testing or non-interactive session, always use defaults if ( ($ENV{AUTOMATED_TESTING} or -! -t STDIN) and ! $ENV{PERL_MM_USE_DEFAULT} ) { local $ENV{PERL_MM_USE_DEFAULT} = 1; goto &ExtUtils::MakeMaker::prompt; } else { goto &ExtUtils::MakeMaker::prompt; } } # Store a cleaned up version of the MakeMaker version, # since we need to behave differently in a variety of # ways based on the MM version. my $makemaker = eval $ExtUtils::MakeMaker::VERSION; # If we are passed a param, do a "newer than" comparison. # Otherwise, just return the MakeMaker version. sub makemaker { ( @_ < 2 or $makemaker >= eval($_[1]) ) ? $makemaker : 0 } # Ripped from ExtUtils::MakeMaker 6.56, and slightly modified # as we only need to know here whether the attribute is an array # or a hash or something else (which may or may not be appendable). my %makemaker_argtype = ( C => 'ARRAY', CONFIG => 'ARRAY', # CONFIGURE => 'CODE', # ignore DIR => 'ARRAY', DL_FUNCS => 'HASH', DL_VARS => 'ARRAY', EXCLUDE_EXT => 'ARRAY', EXE_FILES => 'ARRAY', FUNCLIST => 'ARRAY', H => 'ARRAY', IMPORTS => 'HASH', INCLUDE_EXT => 'ARRAY', LIBS => 'ARRAY', # ignore '' MAN1PODS => 'HASH', MAN3PODS => 'HASH', META_ADD => 'HASH', META_MERGE => 'HASH', PL_FILES => 'HASH', PM => 'HASH', PMLIBDIRS => 'ARRAY', PMLIBPARENTDIRS => 'ARRAY', PREREQ_PM => 'HASH', CONFIGURE_REQUIRES => 'HASH', SKIP => 'ARRAY', TYPEMAPS => 'ARRAY', XS => 'HASH', # VERSION => ['version',''], # ignore # _KEEP_AFTER_FLUSH => '', clean => 'HASH', depend => 'HASH', dist => 'HASH', dynamic_lib=> 'HASH', linkext => 'HASH', macro => 'HASH', postamble => 'HASH', realclean => 'HASH', test => 'HASH', tool_autosplit => 'HASH', # special cases where you can use makemaker_append CCFLAGS => 'APPENDABLE', DEFINE => 'APPENDABLE', INC => 'APPENDABLE', LDDLFLAGS => 'APPENDABLE', LDFROM => 'APPENDABLE', ); sub makemaker_args { my ($self, %new_args) = @_; my $args = ( $self->{makemaker_args} ||= {} ); foreach my $key (keys %new_args) { if ($makemaker_argtype{$key}) { if ($makemaker_argtype{$key} eq 'ARRAY') { $args->{$key} = [] unless defined $args->{$key}; unless (ref $args->{$key} eq 'ARRAY') { $args->{$key} = [$args->{$key}] } push @{$args->{$key}}, ref $new_args{$key} eq 'ARRAY' ? @{$new_args{$key}} : $new_args{$key}; } elsif ($makemaker_argtype{$key} eq 'HASH') { $args->{$key} = {} unless defined $args->{$key}; foreach my $skey (keys %{ $new_args{$key} }) { $args->{$key}{$skey} = $new_args{$key}{$skey}; } } elsif ($makemaker_argtype{$key} eq 'APPENDABLE') { $self->makemaker_append($key => $new_args{$key}); } } else { if (defined $args->{$key}) { warn qq{MakeMaker attribute "$key" is overriden; use "makemaker_append" to append values\n}; } $args->{$key} = $new_args{$key}; } } return $args; } # For mm args that take multiple space-separated args, # append an argument to the current list. sub makemaker_append { my $self = shift; my $name = shift; my $args = $self->makemaker_args; $args->{$name} = defined $args->{$name} ? join( ' ', $args->{$name}, @_ ) : join( ' ', @_ ); } sub build_subdirs { my $self = shift; my $subdirs = $self->makemaker_args->{DIR} ||= []; for my $subdir (@_) { push @$subdirs, $subdir; } } sub clean_files { my $self = shift; my $clean = $self->makemaker_args->{clean} ||= {}; %$clean = ( %$clean, FILES => join ' ', grep { length $_ } ($clean->{FILES} || (), @_), ); } sub realclean_files { my $self = shift; my $realclean = $self->makemaker_args->{realclean} ||= {}; %$realclean = ( %$realclean, FILES => join ' ', grep { length $_ } ($realclean->{FILES} || (), @_), ); } sub libs { my $self = shift; my $libs = ref $_[0] ? shift : [ shift ]; $self->makemaker_args( LIBS => $libs ); } sub inc { my $self = shift; $self->makemaker_args( INC => shift ); } sub _wanted_t { } sub tests_recursive { my $self = shift; my $dir = shift || 't'; unless ( -d $dir ) { die "tests_recursive dir '$dir' does not exist"; } my %tests = map { $_ => 1 } split / /, ($self->tests || ''); require File::Find; File::Find::find( sub { /\.t$/ and -f $_ and $tests{"$File::Find::dir/*.t"} = 1 }, $dir ); $self->tests( join ' ', sort keys %tests ); } sub write { my $self = shift; die "&Makefile->write() takes no arguments\n" if @_; # Check the current Perl version my $perl_version = $self->perl_version; if ( $perl_version ) { eval "use $perl_version; 1" or die "ERROR: perl: Version $] is installed, " . "but we need version >= $perl_version"; } # Make sure we have a new enough MakeMaker require ExtUtils::MakeMaker; if ( $perl_version and $self->_cmp($perl_version, '5.006') >= 0 ) { # This previous attempted to inherit the version of # ExtUtils::MakeMaker in use by the module author, but this # was found to be untenable as some authors build releases # using future dev versions of EU:MM that nobody else has. # Instead, #toolchain suggests we use 6.59 which is the most # stable version on CPAN at time of writing and is, to quote # ribasushi, "not terminally fucked, > and tested enough". # TODO: We will now need to maintain this over time to push # the version up as new versions are released. $self->build_requires( 'ExtUtils::MakeMaker' => 6.59 ); $self->configure_requires( 'ExtUtils::MakeMaker' => 6.59 ); } else { # Allow legacy-compatibility with 5.005 by depending on the # most recent EU:MM that supported 5.005. $self->build_requires( 'ExtUtils::MakeMaker' => 6.36 ); $self->configure_requires( 'ExtUtils::MakeMaker' => 6.36 ); } # Generate the MakeMaker params my $args = $self->makemaker_args; $args->{DISTNAME} = $self->name; $args->{NAME} = $self->module_name || $self->name; $args->{NAME} =~ s/-/::/g; $args->{VERSION} = $self->version or die <<'EOT'; ERROR: Can't determine distribution version. Please specify it explicitly via 'version' in Makefile.PL, or set a valid $VERSION in a module, and provide its file path via 'version_from' (or 'all_from' if you prefer) in Makefile.PL. EOT if ( $self->tests ) { my @tests = split ' ', $self->tests; my %seen; $args->{test} = { TESTS => (join ' ', grep {!$seen{$_}++} @tests), }; } elsif ( $Module::Install::ExtraTests::use_extratests ) { # Module::Install::ExtraTests doesn't set $self->tests and does its own tests via harness. # So, just ignore our xt tests here. } elsif ( -d 'xt' and ($Module::Install::AUTHOR or $ENV{RELEASE_TESTING}) ) { $args->{test} = { TESTS => join( ' ', map { "$_/*.t" } grep { -d $_ } qw{ t xt } ), }; } if ( $] >= 5.005 ) { $args->{ABSTRACT} = $self->abstract; $args->{AUTHOR} = join ', ', @{$self->author || []}; } if ( $self->makemaker(6.10) ) { $args->{NO_META} = 1; #$args->{NO_MYMETA} = 1; } if ( $self->makemaker(6.17) and $self->sign ) { $args->{SIGN} = 1; } unless ( $self->is_admin ) { delete $args->{SIGN}; } if ( $self->makemaker(6.31) and $self->license ) { $args->{LICENSE} = $self->license; } my $prereq = ($args->{PREREQ_PM} ||= {}); %$prereq = ( %$prereq, map { @$_ } # flatten [module => version] map { @$_ } grep $_, ($self->requires) ); # Remove any reference to perl, PREREQ_PM doesn't support it delete $args->{PREREQ_PM}->{perl}; # Merge both kinds of requires into BUILD_REQUIRES my $build_prereq = ($args->{BUILD_REQUIRES} ||= {}); %$build_prereq = ( %$build_prereq, map { @$_ } # flatten [module => version] map { @$_ } grep $_, ($self->configure_requires, $self->build_requires) ); # Remove any reference to perl, BUILD_REQUIRES doesn't support it delete $args->{BUILD_REQUIRES}->{perl}; # Delete bundled dists from prereq_pm, add it to Makefile DIR my $subdirs = ($args->{DIR} || []); if ($self->bundles) { my %processed; foreach my $bundle (@{ $self->bundles }) { my ($mod_name, $dist_dir) = @$bundle; delete $prereq->{$mod_name}; $dist_dir = File::Basename::basename($dist_dir); # dir for building this module if (not exists $processed{$dist_dir}) { if (-d $dist_dir) { # List as sub-directory to be processed by make push @$subdirs, $dist_dir; } # Else do nothing: the module is already present on the system $processed{$dist_dir} = undef; } } } unless ( $self->makemaker('6.55_03') ) { %$prereq = (%$prereq,%$build_prereq); delete $args->{BUILD_REQUIRES}; } if ( my $perl_version = $self->perl_version ) { eval "use $perl_version; 1" or die "ERROR: perl: Version $] is installed, " . "but we need version >= $perl_version"; if ( $self->makemaker(6.48) ) { $args->{MIN_PERL_VERSION} = $perl_version; } } if ($self->installdirs) { warn qq{old INSTALLDIRS (probably set by makemaker_args) is overriden by installdirs\n} if $args->{INSTALLDIRS}; $args->{INSTALLDIRS} = $self->installdirs; } my %args = map { ( $_ => $args->{$_} ) } grep {defined($args->{$_} ) } keys %$args; my $user_preop = delete $args{dist}->{PREOP}; if ( my $preop = $self->admin->preop($user_preop) ) { foreach my $key ( keys %$preop ) { $args{dist}->{$key} = $preop->{$key}; } } my $mm = ExtUtils::MakeMaker::WriteMakefile(%args); $self->fix_up_makefile($mm->{FIRST_MAKEFILE} || 'Makefile'); } sub fix_up_makefile { my $self = shift; my $makefile_name = shift; my $top_class = ref($self->_top) || ''; my $top_version = $self->_top->VERSION || ''; my $preamble = $self->preamble ? "# Preamble by $top_class $top_version\n" . $self->preamble : ''; my $postamble = "# Postamble by $top_class $top_version\n" . ($self->postamble || ''); local *MAKEFILE; open MAKEFILE, "+< $makefile_name" or die "fix_up_makefile: Couldn't open $makefile_name: $!"; eval { flock MAKEFILE, LOCK_EX }; my $makefile = do { local $/; }; $makefile =~ s/\b(test_harness\(\$\(TEST_VERBOSE\), )/$1'inc', /; $makefile =~ s/( -I\$\(INST_ARCHLIB\))/ -Iinc$1/g; $makefile =~ s/( "-I\$\(INST_LIB\)")/ "-Iinc"$1/g; $makefile =~ s/^(FULLPERL = .*)/$1 "-Iinc"/m; $makefile =~ s/^(PERL = .*)/$1 "-Iinc"/m; # Module::Install will never be used to build the Core Perl # Sometimes PERL_LIB and PERL_ARCHLIB get written anyway, which breaks # PREFIX/PERL5LIB, and thus, install_share. Blank them if they exist $makefile =~ s/^PERL_LIB = .+/PERL_LIB =/m; #$makefile =~ s/^PERL_ARCHLIB = .+/PERL_ARCHLIB =/m; # Perl 5.005 mentions PERL_LIB explicitly, so we have to remove that as well. $makefile =~ s/(\"?)-I\$\(PERL_LIB\)\1//g; # XXX - This is currently unused; not sure if it breaks other MM-users # $makefile =~ s/^pm_to_blib\s+:\s+/pm_to_blib :: /mg; seek MAKEFILE, 0, SEEK_SET; truncate MAKEFILE, 0; print MAKEFILE "$preamble$makefile$postamble" or die $!; close MAKEFILE or die $!; 1; } sub preamble { my ($self, $text) = @_; $self->{preamble} = $text . $self->{preamble} if defined $text; $self->{preamble}; } sub postamble { my ($self, $text) = @_; $self->{postamble} ||= $self->admin->postamble; $self->{postamble} .= $text if defined $text; $self->{postamble} } 1; __END__ #line 544 Parse-Method-Signatures-1.003019/inc/Module/Install/Fetch.pm0000644000175000017500000000462713072454012022047 0ustar kentkent#line 1 package Module::Install::Fetch; use strict; use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '1.17'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } sub get_file { my ($self, %args) = @_; my ($scheme, $host, $path, $file) = $args{url} =~ m|^(\w+)://([^/]+)(.+)/(.+)| or return; if ( $scheme eq 'http' and ! eval { require LWP::Simple; 1 } ) { $args{url} = $args{ftp_url} or (warn("LWP support unavailable!\n"), return); ($scheme, $host, $path, $file) = $args{url} =~ m|^(\w+)://([^/]+)(.+)/(.+)| or return; } $|++; print "Fetching '$file' from $host... "; unless (eval { require Socket; Socket::inet_aton($host) }) { warn "'$host' resolve failed!\n"; return; } return unless $scheme eq 'ftp' or $scheme eq 'http'; require Cwd; my $dir = Cwd::getcwd(); chdir $args{local_dir} or return if exists $args{local_dir}; if (eval { require LWP::Simple; 1 }) { LWP::Simple::mirror($args{url}, $file); } elsif (eval { require Net::FTP; 1 }) { eval { # use Net::FTP to get past firewall my $ftp = Net::FTP->new($host, Passive => 1, Timeout => 600); $ftp->login("anonymous", 'anonymous@example.com'); $ftp->cwd($path); $ftp->binary; $ftp->get($file) or (warn("$!\n"), return); $ftp->quit; } } elsif (my $ftp = $self->can_run('ftp')) { eval { # no Net::FTP, fallback to ftp.exe require FileHandle; my $fh = FileHandle->new; local $SIG{CHLD} = 'IGNORE'; unless ($fh->open("|$ftp -n")) { warn "Couldn't open ftp: $!\n"; chdir $dir; return; } my @dialog = split(/\n/, <<"END_FTP"); open $host user anonymous anonymous\@example.com cd $path binary get $file $file quit END_FTP foreach (@dialog) { $fh->print("$_\n") } $fh->close; } } else { warn "No working 'ftp' program available!\n"; chdir $dir; return; } unless (-f $file) { warn "Fetching failed: $@\n"; chdir $dir; return; } return if exists $args{size} and -s $file != $args{size}; system($args{run}) if exists $args{run}; unlink($file) if $args{remove}; print(((!exists $args{check_for} or -e $args{check_for}) ? "done!" : "failed! ($!)"), "\n"); chdir $dir; return !$?; } 1; Parse-Method-Signatures-1.003019/META.yml0000644000175000017500000000433613072454012016322 0ustar kentkent--- abstract: 'Perl6 like method signature parser' author: - 'Ash Berlin .' build_requires: ExtUtils::MakeMaker: 6.36 MooseX::Types::Structured: 0 Test::Differences: 0 Test::Exception: 0 Test::More: 0 aliased: 0 configure_requires: ExtUtils::MakeMaker: 6.36 distribution_type: module dynamic_config: 1 generated_by: 'Module::Install version 1.17' license: perl meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: 1.4 name: Parse-Method-Signatures no_index: directory: - inc - t provides: Parse::Method::Signatures: file: lib/Parse/Method/Signatures.pm version: '1.003019' Parse::Method::Signatures::Param: file: lib/Parse/Method/Signatures/Param.pm Parse::Method::Signatures::Param::Bindable: file: lib/Parse/Method/Signatures/Param/Bindable.pm Parse::Method::Signatures::Param::Named: file: lib/Parse/Method/Signatures/Param/Named.pm Parse::Method::Signatures::Param::Placeholder: file: lib/Parse/Method/Signatures/Param/Placeholder.pm Parse::Method::Signatures::Param::Positional: file: lib/Parse/Method/Signatures/Param/Positional.pm Parse::Method::Signatures::Param::Unpacked: file: lib/Parse/Method/Signatures/Param/Unpacked.pm Parse::Method::Signatures::Param::Unpacked::Array: file: lib/Parse/Method/Signatures/Param/Unpacked/Array.pm Parse::Method::Signatures::Param::Unpacked::Hash: file: lib/Parse/Method/Signatures/Param/Unpacked/Hash.pm Parse::Method::Signatures::ParamCollection: file: lib/Parse/Method/Signatures/ParamCollection.pm Parse::Method::Signatures::Sig: file: lib/Parse/Method/Signatures/Sig.pm Parse::Method::Signatures::TypeConstraint: file: lib/Parse/Method/Signatures/TypeConstraint.pm Parse::Method::Signatures::Types: file: lib/Parse/Method/Signatures/Types.pm requires: Class::Load: '0.19' List::MoreUtils: '0.20' Moose: 0 MooseX::Traits: '0.06' MooseX::Types: '0.17' MooseX::Types::Moose: 0 MooseX::Types::Structured: 0 PPI: '1.203' namespace::clean: '0.10' resources: homepage: http://github.com/ashb/Parse-Method-Signatures/tree/master license: http://dev.perl.org/licenses/ repository: git://github.com/ashb/Parse-Method-Signatures.git version: '1.003019' Parse-Method-Signatures-1.003019/MANIFEST0000644000175000017500000000171713072453672016215 0ustar kentkentChanges inc/Module/AutoInstall.pm inc/Module/Install.pm inc/Module/Install/AutoInstall.pm inc/Module/Install/Base.pm inc/Module/Install/Can.pm inc/Module/Install/Fetch.pm inc/Module/Install/Include.pm inc/Module/Install/Makefile.pm inc/Module/Install/Metadata.pm inc/Module/Install/Win32.pm inc/Module/Install/WriteAll.pm lib/Parse/Method/Signatures.pm lib/Parse/Method/Signatures/Param.pm lib/Parse/Method/Signatures/Param/Bindable.pm lib/Parse/Method/Signatures/Param/Named.pm lib/Parse/Method/Signatures/Param/Placeholder.pm lib/Parse/Method/Signatures/Param/Positional.pm lib/Parse/Method/Signatures/Param/Unpacked.pm lib/Parse/Method/Signatures/Param/Unpacked/Array.pm lib/Parse/Method/Signatures/Param/Unpacked/Hash.pm lib/Parse/Method/Signatures/ParamCollection.pm lib/Parse/Method/Signatures/Sig.pm lib/Parse/Method/Signatures/TypeConstraint.pm lib/Parse/Method/Signatures/Types.pm Makefile.PL MANIFEST This list of files META.yml t/ppi.t t/signatures.t t/struct.t