diff --git a/Makefile.PL b/Makefile.PL new file mode 100644 index 0000000..7572d30 --- /dev/null +++ b/Makefile.PL @@ -0,0 +1,59 @@ +# This file was automatically generated by Dist::Zilla::Plugin::MakeMaker v6.029. +use strict; +use warnings; + +use 5.008000; + +use ExtUtils::MakeMaker 6.78; + +my %WriteMakefileArgs = ( + "ABSTRACT" => "install subroutines into packages easily", + "AUTHOR" => "Ricardo SIGNES ", + "CONFIGURE_REQUIRES" => { + "ExtUtils::MakeMaker" => "6.78" + }, + "DISTNAME" => "Sub-Install", + "LICENSE" => "perl", + "MIN_PERL_VERSION" => "5.008000", + "NAME" => "Sub::Install", + "PREREQ_PM" => { + "B" => 0, + "Carp" => 0, + "Scalar::Util" => 0, + "strict" => 0, + "warnings" => 0 + }, + "TEST_REQUIRES" => { + "ExtUtils::MakeMaker" => 0, + "File::Spec" => 0, + "Test::More" => "0.96" + }, + "VERSION" => "0.929", + "test" => { + "TESTS" => "t/*.t" + } +); + + +my %FallbackPrereqs = ( + "B" => 0, + "Carp" => 0, + "ExtUtils::MakeMaker" => 0, + "File::Spec" => 0, + "Scalar::Util" => 0, + "Test::More" => "0.96", + "strict" => 0, + "warnings" => 0 +); + + +unless ( eval { ExtUtils::MakeMaker->VERSION(6.63_03) } ) { + delete $WriteMakefileArgs{TEST_REQUIRES}; + delete $WriteMakefileArgs{BUILD_REQUIRES}; + $WriteMakefileArgs{PREREQ_PM} = \%FallbackPrereqs; +} + +delete $WriteMakefileArgs{CONFIGURE_REQUIRES} + unless eval { ExtUtils::MakeMaker->VERSION(6.52) }; + +WriteMakefile(%WriteMakefileArgs); diff --git a/lib/Sub/Install.pm b/lib/Sub/Install.pm index 635c0ab..8b7f495 100644 --- a/lib/Sub/Install.pm +++ b/lib/Sub/Install.pm @@ -1,75 +1,76 @@ +use v5.8.0; use strict; use warnings; package Sub::Install; # ABSTRACT: install subroutines into packages easily - +$Sub::Install::VERSION = '0.929'; use Carp; use Scalar::Util (); -=head1 SYNOPSIS - - use Sub::Install; - - Sub::Install::install_sub({ - code => sub { ... }, - into => $package, - as => $subname - }); - -=head1 DESCRIPTION - -This module makes it easy to install subroutines into packages without the -unsightly mess of C or typeglobs lying about where just anyone can -see them. - -=func install_sub - - Sub::Install::install_sub({ - code => \&subroutine, - into => "Finance::Shady", - as => 'launder', - }); - -This routine installs a given code reference into a package as a normal -subroutine. The above is equivalent to: - - no strict 'refs'; - *{"Finance::Shady" . '::' . "launder"} = \&subroutine; - -If C is not given, the sub is installed into the calling package. - -If C is not a code reference, it is looked for as an existing sub in the -package named in the C parameter. If C is not given, it will look -in the calling package. - -If C is not given, and if C is a name, C will default to C. -If C is not given, but if C is a code ref, Sub::Install will try to -find the name of the given code ref and use that as C. - -That means that this code: - - Sub::Install::install_sub({ - code => 'twitch', - from => 'Person::InPain', - into => 'Person::Teenager', - as => 'dance', - }); - -is the same as: - - package Person::Teenager; - - Sub::Install::install_sub({ - code => Person::InPain->can('twitch'), - as => 'dance', - }); - -=func reinstall_sub - -This routine behaves exactly like C>, but does not emit a -warning if warnings are on and the destination is already defined. - -=cut +#pod =head1 SYNOPSIS +#pod +#pod use Sub::Install; +#pod +#pod Sub::Install::install_sub({ +#pod code => sub { ... }, +#pod into => $package, +#pod as => $subname +#pod }); +#pod +#pod =head1 DESCRIPTION +#pod +#pod This module makes it easy to install subroutines into packages without the +#pod unsightly mess of C or typeglobs lying about where just anyone can +#pod see them. +#pod +#pod =func install_sub +#pod +#pod Sub::Install::install_sub({ +#pod code => \&subroutine, +#pod into => "Finance::Shady", +#pod as => 'launder', +#pod }); +#pod +#pod This routine installs a given code reference into a package as a normal +#pod subroutine. The above is equivalent to: +#pod +#pod no strict 'refs'; +#pod *{"Finance::Shady" . '::' . "launder"} = \&subroutine; +#pod +#pod If C is not given, the sub is installed into the calling package. +#pod +#pod If C is not a code reference, it is looked for as an existing sub in the +#pod package named in the C parameter. If C is not given, it will look +#pod in the calling package. +#pod +#pod If C is not given, and if C is a name, C will default to C. +#pod If C is not given, but if C is a code ref, Sub::Install will try to +#pod find the name of the given code ref and use that as C. +#pod +#pod That means that this code: +#pod +#pod Sub::Install::install_sub({ +#pod code => 'twitch', +#pod from => 'Person::InPain', +#pod into => 'Person::Teenager', +#pod as => 'dance', +#pod }); +#pod +#pod is the same as: +#pod +#pod package Person::Teenager; +#pod +#pod Sub::Install::install_sub({ +#pod code => Person::InPain->can('twitch'), +#pod as => 'dance', +#pod }); +#pod +#pod =func reinstall_sub +#pod +#pod This routine behaves exactly like C>, but does not emit a +#pod warning if warnings are on and the destination is already defined. +#pod +#pod =cut sub _name_of_code { my ($code) = @_; @@ -193,28 +194,28 @@ BEGIN { }); } -=func install_installers - -This routine is provided to allow Sub::Install compatibility with -Sub::Installer. It installs C and C methods into -the package named by its argument. - - Sub::Install::install_installers('Code::Builder'); # just for us, please - Code::Builder->install_sub({ name => $code_ref }); - - Sub::Install::install_installers('UNIVERSAL'); # feeling lucky, punk? - Anything::At::All->install_sub({ name => $code_ref }); - -The installed installers are similar, but not identical, to those provided by -Sub::Installer. They accept a single hash as an argument. The key/value pairs -are used as the C and C parameters to the C routine -detailed above. The package name on which the method is called is used as the -C parameter. - -Unlike Sub::Installer's C will not eval strings into code, but -will look for named code in the calling package. - -=cut +#pod =func install_installers +#pod +#pod This routine is provided to allow Sub::Install compatibility with +#pod Sub::Installer. It installs C and C methods into +#pod the package named by its argument. +#pod +#pod Sub::Install::install_installers('Code::Builder'); # just for us, please +#pod Code::Builder->install_sub({ name => $code_ref }); +#pod +#pod Sub::Install::install_installers('UNIVERSAL'); # feeling lucky, punk? +#pod Anything::At::All->install_sub({ name => $code_ref }); +#pod +#pod The installed installers are similar, but not identical, to those provided by +#pod Sub::Installer. They accept a single hash as an argument. The key/value pairs +#pod are used as the C and C parameters to the C routine +#pod detailed above. The package name on which the method is called is used as the +#pod C parameter. +#pod +#pod Unlike Sub::Installer's C will not eval strings into code, but +#pod will look for named code in the calling package. +#pod +#pod =cut sub install_installers { my ($into) = @_; @@ -238,22 +239,22 @@ sub install_installers { } } -=head1 EXPORTS - -Sub::Install exports C and C only if they are -requested. - -=head2 exporter - -Sub::Install has a never-exported subroutine called C, which is used -to implement its C routine. It takes a hashref of named arguments, -only one of which is currently recognize: C. This must be an arrayref -of subroutines to offer for export. - -This routine is mainly for Sub::Install's own consumption. Instead, consider -L. - -=cut +#pod =head1 EXPORTS +#pod +#pod Sub::Install exports C and C only if they are +#pod requested. +#pod +#pod =head2 exporter +#pod +#pod Sub::Install has a never-exported subroutine called C, which is used +#pod to implement its C routine. It takes a hashref of named arguments, +#pod only one of which is currently recognize: C. This must be an arrayref +#pod of subroutines to offer for export. +#pod +#pod This routine is mainly for Sub::Install's own consumption. Instead, consider +#pod L. +#pod +#pod =cut sub exporter { my ($arg) = @_; @@ -272,6 +273,158 @@ sub exporter { BEGIN { *import = exporter({ exports => [ qw(install_sub reinstall_sub) ] }); } +#pod =head1 SEE ALSO +#pod +#pod =over +#pod +#pod =item L +#pod +#pod This module is (obviously) a reaction to Damian Conway's Sub::Installer, which +#pod does the same thing, but does it by getting its greasy fingers all over +#pod UNIVERSAL. I was really happy about the idea of making the installation of +#pod coderefs less ugly, but I couldn't bring myself to replace the ugliness of +#pod typeglobs and loosened strictures with the ugliness of UNIVERSAL methods. +#pod +#pod =item L +#pod +#pod This is a complete Exporter.pm replacement, built atop Sub::Install. +#pod +#pod =back +#pod +#pod =head1 EXTRA CREDITS +#pod +#pod Several of the tests are adapted from tests that shipped with Damian Conway's +#pod Sub-Installer distribution. +#pod +#pod =cut + +1; + +__END__ + +=pod + +=encoding UTF-8 + +=head1 NAME + +Sub::Install - install subroutines into packages easily + +=head1 VERSION + +version 0.929 + +=head1 SYNOPSIS + + use Sub::Install; + + Sub::Install::install_sub({ + code => sub { ... }, + into => $package, + as => $subname + }); + +=head1 DESCRIPTION + +This module makes it easy to install subroutines into packages without the +unsightly mess of C or typeglobs lying about where just anyone can +see them. + +=head1 PERL VERSION + +This library should run on perls released even an extremely long time ago. It +should work on any version of perl released in the last ten years. + +Although it may work on older versions of perl, no guarantee is made that the +minimum required version will not be increased. The version may be increased +for any reason, and there is no promise that patches will be accepted to lower +the minimum required perl. + +=head1 FUNCTIONS + +=head2 install_sub + + Sub::Install::install_sub({ + code => \&subroutine, + into => "Finance::Shady", + as => 'launder', + }); + +This routine installs a given code reference into a package as a normal +subroutine. The above is equivalent to: + + no strict 'refs'; + *{"Finance::Shady" . '::' . "launder"} = \&subroutine; + +If C is not given, the sub is installed into the calling package. + +If C is not a code reference, it is looked for as an existing sub in the +package named in the C parameter. If C is not given, it will look +in the calling package. + +If C is not given, and if C is a name, C will default to C. +If C is not given, but if C is a code ref, Sub::Install will try to +find the name of the given code ref and use that as C. + +That means that this code: + + Sub::Install::install_sub({ + code => 'twitch', + from => 'Person::InPain', + into => 'Person::Teenager', + as => 'dance', + }); + +is the same as: + + package Person::Teenager; + + Sub::Install::install_sub({ + code => Person::InPain->can('twitch'), + as => 'dance', + }); + +=head2 reinstall_sub + +This routine behaves exactly like C>, but does not emit a +warning if warnings are on and the destination is already defined. + +=head2 install_installers + +This routine is provided to allow Sub::Install compatibility with +Sub::Installer. It installs C and C methods into +the package named by its argument. + + Sub::Install::install_installers('Code::Builder'); # just for us, please + Code::Builder->install_sub({ name => $code_ref }); + + Sub::Install::install_installers('UNIVERSAL'); # feeling lucky, punk? + Anything::At::All->install_sub({ name => $code_ref }); + +The installed installers are similar, but not identical, to those provided by +Sub::Installer. They accept a single hash as an argument. The key/value pairs +are used as the C and C parameters to the C routine +detailed above. The package name on which the method is called is used as the +C parameter. + +Unlike Sub::Installer's C will not eval strings into code, but +will look for named code in the calling package. + +=head1 EXPORTS + +Sub::Install exports C and C only if they are +requested. + +=head2 exporter + +Sub::Install has a never-exported subroutine called C, which is used +to implement its C routine. It takes a hashref of named arguments, +only one of which is currently recognize: C. This must be an arrayref +of subroutines to offer for export. + +This routine is mainly for Sub::Install's own consumption. Instead, consider +L. + =head1 SEE ALSO =over @@ -295,6 +448,39 @@ This is a complete Exporter.pm replacement, built atop Sub::Install. Several of the tests are adapted from tests that shipped with Damian Conway's Sub-Installer distribution. -=cut +=head1 AUTHOR -1; +Ricardo SIGNES + +=head1 CONTRIBUTORS + +=for stopwords Chad Granum David Steinbrunner Ricardo SIGNES Signes + +=over 4 + +=item * + +Chad Granum + +=item * + +David Steinbrunner + +=item * + +Ricardo SIGNES + +=item * + +Ricardo Signes + +=back + +=head1 COPYRIGHT AND LICENSE + +This software is copyright (c) 2005 by Ricardo SIGNES. + +This is free software; you can redistribute it and/or modify it under +the same terms as the Perl 5 programming language system itself. + +=cut diff --git a/xt/author/pod-syntax.t b/xt/author/pod-syntax.t new file mode 100644 index 0000000..e563e5d --- /dev/null +++ b/xt/author/pod-syntax.t @@ -0,0 +1,7 @@ +#!perl +# This file was automatically generated by Dist::Zilla::Plugin::PodSyntaxTests. +use strict; use warnings; +use Test::More; +use Test::Pod 1.41; + +all_pod_files_ok(); diff --git a/xt/release/changes_has_content.t b/xt/release/changes_has_content.t new file mode 100644 index 0000000..a8c2783 --- /dev/null +++ b/xt/release/changes_has_content.t @@ -0,0 +1,42 @@ +use Test::More tests => 2; + +note 'Checking Changes'; +my $changes_file = 'Changes'; +my $newver = '0.929'; +my $trial_token = '-TRIAL'; +my $encoding = 'UTF-8'; + +SKIP: { + ok(-e $changes_file, "$changes_file file exists") + or skip 'Changes is missing', 1; + + ok(_get_changes($newver), "$changes_file has content for $newver"); +} + +done_testing; + +sub _get_changes +{ + my $newver = shift; + + # parse changelog to find commit message + open(my $fh, '<', $changes_file) or die "cannot open $changes_file: $!"; + my $changelog = join('', <$fh>); + if ($encoding) { + require Encode; + $changelog = Encode::decode($encoding, $changelog, Encode::FB_CROAK()); + } + close $fh; + + my @content = + grep { /^$newver(?:$trial_token)?(?:\s+|$)/ ... /^\S/ } # from newver to un-indented + split /\n/, $changelog; + shift @content; # drop the version line + + # drop unindented last line and trailing blank lines + pop @content while ( @content && $content[-1] =~ /^(?:\S|\s*$)/ ); + + # return number of non-blank lines + return scalar @content; +} +