Exporter-Lite-0.02/0000755000076500007650000000000010525463272014062 5ustar schwernschwernExporter-Lite-0.02/lib/0000755000076500007650000000000010525463266014633 5ustar schwernschwernExporter-Lite-0.02/lib/Exporter/0000755000076500007650000000000010525463266016443 5ustar schwernschwernExporter-Lite-0.02/lib/Exporter/Lite.pm0000644000076500007650000001214010525461567017676 0ustar schwernschwernpackage Exporter::Lite; require 5.004; # Using strict or vars almost doubles our load time. Turn them back # on when debugging. #use strict 'vars'; # we're going to be doing a lot of sym refs #use vars qw($VERSION @EXPORT); $VERSION = 0.02; @EXPORT = qw(import); # we'll know pretty fast if it doesn't work :) sub import { my($exporter, @imports) = @_; my($caller, $file, $line) = caller; unless( @imports ) { # Default import. @imports = @{$exporter.'::EXPORT'}; } else { # Because @EXPORT_OK = () would indicate that nothing is # to be exported, we cannot simply check the length of @EXPORT_OK. # We must to oddness to see if the variable exists at all as # well as avoid autovivification. # XXX idea stolen from base.pm, this might be all unnecessary my $eokglob; if( $eokglob = ${$exporter.'::'}{EXPORT_OK} and *$eokglob{ARRAY} ) { if( @{$exporter.'::EXPORT_OK'} ) { # This can also be cached. my %ok = map { s/^&//; $_ => 1 } @{$exporter.'::EXPORT_OK'}, @{$exporter.'::EXPORT'}; my($denied) = grep {s/^&//; !$ok{$_}} @imports; _not_exported($denied, $exporter, $file, $line) if $denied; } else { # We don't export anything. _not_exported($imports[0], $exporter, $file, $line); } } } _export($caller, $exporter, @imports); } sub _export { my($caller, $exporter, @imports) = @_; # Stole this from Exporter::Heavy. I'm sure it can be written better # but I'm lazy at the moment. foreach my $sym (@imports) { # shortcut for the common case of no type character (*{$caller.'::'.$sym} = \&{$exporter.'::'.$sym}, next) unless $sym =~ s/^(\W)//; my $type = $1; my $caller_sym = $caller.'::'.$sym; my $export_sym = $exporter.'::'.$sym; *{$caller_sym} = $type eq '&' ? \&{$export_sym} : $type eq '$' ? \${$export_sym} : $type eq '@' ? \@{$export_sym} : $type eq '%' ? \%{$export_sym} : $type eq '*' ? *{$export_sym} : do { require Carp; Carp::croak("Can't export symbol: $type$sym") }; } } #"# sub _not_exported { my($thing, $exporter, $file, $line) = @_; die sprintf qq|"%s" is not exported by the %s module at %s line %d\n|, $thing, $exporter, $file, $line; } 1; __END__ =head1 NAME Exporter::Lite - Lightweight exporting of variables =head1 SYNOPSIS package Foo; use Exporter::Lite; # Just like Exporter. @EXPORT = qw($This That); @EXPORT_OK = qw(@Left %Right); # Meanwhile, in another piece of code! package Bar; use Foo; # exports $This and &That. =head1 DESCRIPTION This is an alternative to Exporter intended to provide a lightweight subset of its functionality. It supports C, C<@EXPORT> and C<@EXPORT_OK> and not a whole lot else. Unlike Exporter, it is not necessary to inherit from Exporter::Lite (ie. no C<@ISA = qw(Exporter::Lite)> mantra). Exporter::Lite simply exports its import() function. This might be called a "mix-in". Setting up a module to export its variables and functions is simple: package My::Module; use Exporter::Lite; @EXPORT = qw($Foo bar); now when you C, C<$Foo> and C will show up. In order to make exporting optional, use @EXPORT_OK. package My::Module; use Exporter::Lite; @EXPORT_OK = qw($Foo bar); when My::Module is used, C<$Foo> and C will I show up. You have to ask for them. C. =head1 Methods Export::Lite has one public method, import(), which is called automaticly when your modules is use()'d. In normal usage you don't have to worry about this at all. =over 4 =item B Some::Module->import; Some::Module->import(@symbols); Works just like C excepting it only honors @Some::Module::EXPORT and @Some::Module::EXPORT_OK. The given @symbols are exported to the current package provided they are in @Some::Module::EXPORT or @Some::Module::EXPORT_OK. Otherwise an exception is thrown (ie. the program dies). If @symbols is not given, everything in @Some::Module::EXPORT is exported. =back =head1 DIAGNOSTICS =over 4 =item '"%s" is not exported by the %s module' Attempted to import a symbol which is not in @EXPORT or @EXPORT_OK. =item 'Can\'t export symbol: %s' Attempted to import a symbol of an unknown type (ie. the leading $@% salad wasn't recognized). =back =head1 BUGS and CAVEATS Its not yet clear if this is actually any lighter or faster than Exporter. I know its at least on par. OTOH, the docs are much clearer and not having to say C<@ISA = qw(Exporter)> is kinda nice. =head1 AUTHORS Michael G Schwern =head1 LICENSE This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See F =head1 SEE ALSO L, L, L =cut Exporter-Lite-0.02/Makefile.PL0000644000076500007650000000244610525463050016034 0ustar schwernschwern#!/usr/bin/perl -w use ExtUtils::MakeMaker; $PACKAGE = 'Exporter::Lite'; ($PACKAGE_FILE = $PACKAGE) =~ s|::|/|g; $LAST_API_CHANGE = 0; eval "require $PACKAGE"; unless ($@) { # Make sure we did find the module. print <<"CHANGE_WARN" if ${$PACKAGE.'::VERSION'} < $LAST_API_CHANGE; NOTE: There have been API changes between this version and any older than version $LAST_API_CHANGE! Please read the Changes file if you are upgrading from a version older than $LAST_API_CHANGE. CHANGE_WARN } WriteMakefile( NAME => $PACKAGE, VERSION_FROM => "lib/$PACKAGE_FILE.pm", # finds $VERSION PREREQ_PM => { Test::More => 0.34 }, ($ExtUtils::MakeMaker::VERSION <= 6.31 ? (LICENSE => 'perl') : ()), ); { package MY; sub test_via_harness { my($self, $orig_perl, $tests) = @_; my @perls = ($orig_perl); push @perls, qw(bleadperl perl5.6.1 perl5.6.0 perl5.005_03 perl5.004_05 perl5.004_04 perl5.004) if $ENV{PERL_TEST_ALL}; my $out; foreach my $perl (@perls) { $out .= $self->SUPER::test_via_harness($perl, $tests); } return $out; } } Exporter-Lite-0.02/MANIFEST0000644000076500007650000000035510525463266015221 0ustar schwernschwernMANIFEST Makefile.PL lib/Exporter/Lite.pm t/Exporter-Lite.t t/lib/Dummy.pm META.yml Module meta-data (added by MakeMaker) SIGNATURE Public-key signature (added by MakeMaker) Exporter-Lite-0.02/META.yml0000664000076500007650000000054610525463266015345 0ustar schwernschwern--- #YAML:1.0 name: Exporter-Lite version: 0.02 abstract: ~ license: perl generated_by: ExtUtils::MakeMaker version 6.31 distribution_type: module requires: Test::More: 0.34 meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.2.html version: 1.2 Exporter-Lite-0.02/SIGNATURE0000664000076500007650000000207010525463272015347 0ustar schwernschwernThis file contains message digests of all files listed in MANIFEST, signed via the Module::Signature module, version 0.55. To verify the content in this distribution, first make sure you have Module::Signature installed, then type: % cpansign -v It will check each file's integrity, as well as the signature's validity. If "==> Signature verified OK! <==" is not displayed, the distribution may already have been compromised, and you should not run its Makefile.PL or Build.PL. -----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 SHA1 37dc36a06aa00dbfc85d43390ce4d03e25b3eddd MANIFEST SHA1 a938d857885a4ac9421bc3b640568f24a0d9ca2d META.yml SHA1 68983e2578d6936968dc147d0d19c12e99aefa66 Makefile.PL SHA1 f1ff6ad424b0ba6a4dc03b1bbfa4152b6a1ad3cc lib/Exporter/Lite.pm SHA1 89a622e04817b25dae1cdf51b56f25c7b3432fbd t/Exporter-Lite.t SHA1 7154c027605cbb43345a88a80d5fd82184d68652 t/lib/Dummy.pm -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.5 (Darwin) iD8DBQFFVma6WMohlhD1QycRAp2KAKC9vpMDK40IyF3Xqer6JdArbkaBxACfWbyw 4inSb0Z1PP7eFQezUIWYGOg= =G7lI -----END PGP SIGNATURE----- Exporter-Lite-0.02/t/0000755000076500007650000000000010525463266014330 5ustar schwernschwernExporter-Lite-0.02/t/Exporter-Lite.t0000644000076500007650000000501510525462711017213 0ustar schwernschwern#!/usr/bin/perl -w use lib qw(t/lib); use Test::More tests => 30; BEGIN { use_ok('Exporter::Lite'); } can_ok(__PACKAGE__, 'import'); { package Test1; use Dummy; ::can_ok('Dummy', 'import'); ::ok( defined &foo, '@EXPORT' ); ::is( foo, 42, ' in one piece' ); ::is( $foo, 'foofer', ' and variables' ); } { package YATest1; use Dummy qw(foo); ::ok( defined &foo, '@EXPORT with explicit request' ); ::is( foo, 42, ' in one piece' ); } { package Test2; use Dummy (); ::ok( !defined &foo, 'import with ()' ); } { package Test3; eval { Dummy->import('car') }; ::like( $@, '/"car" is not exported by the Dummy module/', 'importing non-expoted function' ); } { package Test4; use Dummy qw(bar); ::ok( defined &bar, '@EXPORT_OK' ); ::ok( !defined &foo, ' overrides @EXPORT' ); ::ok( !defined &my_sum, ' only what we asked for from @EXPORT_OK' ); ::is( bar, 23, ' not damaged in transport' ); } { package YATest4; use Dummy qw(bar $bar); ::ok( defined &bar, '@EXPORT_OK' ); ::ok( !defined &foo, ' overrides @EXPORT' ); ::ok( !defined &my_sum, ' only what we asked for from @EXPORT_OK' ); ::is( bar, 23, ' not damaged in transport' ); ::is( $bar, 'barfer', ' $bar exported' ); } { package Test5; my $warning = ''; local $SIG{__WARN__} = sub { $warning = join '', @_ }; eval 'use Dummy qw(bar)'; eval 'use Dummy qw(&bar)'; ::ok( defined &bar, 'importing multiple times' ); ::is( $@, '', ' no errors' ); ::is( $warning, '', ' no warnings' ); } { package Test6; my $warning = ''; local $SIG{__WARN__} = sub { $warning = join '', @_ }; eval 'use Dummy qw(bar &bar bar bar &bar bar)'; ::ok( defined &bar, 'importing duplicates' ); ::is( $@, '', ' no errors' ); ::is( $warning, '', ' no warnings' ); } { package Test7; use Dummy qw(my_sum bar foo); ::is( prototype("Dummy::my_sum"), '&@', 'imported sub has prototype' ); ::is( prototype("my_sum"), '&@', ' prototype preserved' ); my @list = qw(1 2 3 4); my $sum = my_sum { $_[0] + $_[1] } @list; ::is( $sum, 10, ' and it works' ); } { package Test8; eval "use Dummy 0.5"; ::is( $@, '', 'use Foo VERSION' ); eval "use Dummy 99"; ::like( $@, '/Dummy version 99.* required/', 'use with version check' ); } Exporter-Lite-0.02/t/lib/0000755000076500007650000000000010525463266015076 5ustar schwernschwernExporter-Lite-0.02/t/lib/Dummy.pm0000644000076500007650000000052707407251471016531 0ustar schwernschwernpackage Dummy; use Exporter::Lite; @EXPORT = qw(&foo $foo); @EXPORT_OK = qw(&bar my_sum $bar); $VERSION = 0.5; $foo = 'foofer'; sub foo { 42 } $bar = 'barfer'; sub bar { 23 } sub my_sum (&@) { my($sub, @list) = @_; foreach (@list) { $sum = $sub->($_, $sum || 0); } return $sum; } sub car { "yarblockos" } return 23;