Package-Variant-1.001004/000755 000767 000024 00000000000 12141235225 015145 5ustar00etherstaff000000 000000 Package-Variant-1.001004/Changes000644 000767 000024 00000000771 12141235173 016447 0ustar00etherstaff000000 000000 1.001004 - 2013-05-04 - fix documentation of "build_variant_of" method (RT#84554 -- thanks, Scott Miller!) 1.001003 - 2013-03-25 - fix NAME in Makefile.PL (RT#84209) 1.001002 - 2012-09-19 - Declare the Test::Fatal build dependency 1.001001 - 2012-05-12 - Actually declare the Import::Into dependency (stupid mst) 1.001000 - 2012-05-12 - Switch to Import::Into for exporting other things - Use Sub::Name to name installed things if available 1.000000 - 2012-01-23 - initial release Package-Variant-1.001004/lib/000755 000767 000024 00000000000 12141235225 015713 5ustar00etherstaff000000 000000 Package-Variant-1.001004/maint/000755 000767 000024 00000000000 12141235225 016255 5ustar00etherstaff000000 000000 Package-Variant-1.001004/Makefile.PL000644 000767 000024 00000001424 12124220040 017106 0ustar00etherstaff000000 000000 use strict; use warnings FATAL => 'all'; use ExtUtils::MakeMaker; (do 'maint/Makefile.PL.include' or die $@) unless -f 'META.yml'; WriteMakefile( NAME => 'Package::Variant', VERSION_FROM => 'lib/Package/Variant.pm', CONFIGURE_REQUIRES => { 'ExtUtils::MakeMaker' => '6.55_01', # for BUILD_REQUIRES }, BUILD_REQUIRES => { 'Test::Fatal' => 0 }, PREREQ_PM => { strictures => 1, Carp => 0, 'Import::Into' => 1, 'Module::Runtime' => '0.013', }, META_MERGE => { dynamic_config => 0, resources => { # r/w: p5sagit@git.shadowcat.co.uk:Package-Variant.git repository => 'git://git.shadowcat.co.uk/p5sagit/Package-Variant.git', homepage => 'http://git.shadowcat.co.uk/gitweb/gitweb.cgi?p=p5sagit/Package-Variant.git', }, }, ); Package-Variant-1.001004/MANIFEST000644 000767 000024 00000000635 12141235225 016302 0ustar00etherstaff000000 000000 Changes lib/Package/Variant.pm maint/Makefile.PL.include Makefile.PL MANIFEST This list of files t/01simple.t t/10argument-types.t t/11dynamic-build.t t/20moo-param-role.t META.yml Module YAML meta-data (added by MakeMaker) META.json Module JSON meta-data (added by MakeMaker) README README file (added by Distar) Package-Variant-1.001004/META.json000644 000767 000024 00000002314 12141235225 016566 0ustar00etherstaff000000 000000 { "abstract" : "Parameterizable packages", "author" : [ "mst - Matt S. Trout (cpan:MSTROUT) " ], "dynamic_config" : 0, "generated_by" : "ExtUtils::MakeMaker version 6.66, CPAN::Meta::Converter version 2.130880", "license" : [ "perl_5" ], "meta-spec" : { "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec", "version" : "2" }, "name" : "Package-Variant", "no_index" : { "directory" : [ "t", "inc" ] }, "prereqs" : { "build" : { "requires" : { "Test::Fatal" : "0" } }, "configure" : { "requires" : { "ExtUtils::MakeMaker" : "6.55_01" } }, "runtime" : { "requires" : { "Carp" : "0", "Import::Into" : "1", "Module::Runtime" : "0.013", "strictures" : "1" } } }, "release_status" : "stable", "resources" : { "homepage" : "http://git.shadowcat.co.uk/gitweb/gitweb.cgi?p=p5sagit/Package-Variant.git", "repository" : { "url" : "git://git.shadowcat.co.uk/p5sagit/Package-Variant.git" } }, "version" : "1.001004" } Package-Variant-1.001004/META.yml000644 000767 000024 00000001334 12141235225 016417 0ustar00etherstaff000000 000000 --- abstract: 'Parameterizable packages' author: - 'mst - Matt S. Trout (cpan:MSTROUT) ' build_requires: Test::Fatal: 0 configure_requires: ExtUtils::MakeMaker: 6.55_01 dynamic_config: 0 generated_by: 'ExtUtils::MakeMaker version 6.66, CPAN::Meta::Converter version 2.130880' license: perl meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: 1.4 name: Package-Variant no_index: directory: - t - inc requires: Carp: 0 Import::Into: 1 Module::Runtime: 0.013 strictures: 1 resources: homepage: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?p=p5sagit/Package-Variant.git repository: git://git.shadowcat.co.uk/p5sagit/Package-Variant.git version: 1.001004 Package-Variant-1.001004/README000644 000767 000024 00000021364 12141235225 016033 0ustar00etherstaff000000 000000 NAME Package::Variant - Parameterizable packages SYNOPSIS # declaring a variable Moo role package My::Role::ObjectAttr; use strictures 1; use Package::Variant # what modules to 'use' importing => ['Moo::Role'], # proxied subroutines subs => [ qw(has around before after with) ], sub make_variant { my ($class, $target_package, %arguments) = @_; # access arguments my $name = $arguments{name}; # use proxied 'has' to add an attribute has $name => (is => 'lazy'); # install a builder method install "_build_${name}" => sub { return $arguments{class}->new; }; } # using the role package My::Class::WithObjectAttr; use strictures 1; use Moo; use My::Role::ObjectAttr; with ObjectAttr(name => 'some_obj', class => 'Some::Class'); # using our class my $obj = My::Class::WithObjectAttr->new; $obj->some_obj; # returns a Some::Class instance DESCRIPTION This module allows you to build packages that return different variations depending on what parameters are given. Users of your package will receive a subroutine able to take parameters and return the name of a suitable variant package. The implmenetation does not care about what kind of package it builds. Declaring a variable package There are two important parts to creating a variable package. You first have to give "Package::Variant" some basic information about what kind of package you want to provide, and how. The second part is implementing a method receiving the user's arguments and generating your variants. Setting up the environment for building variations When you "use Package::Variant", you pass along some arguments that describe how you intend to build your variations. use Package::Variant importing => { $package => \@import_arguments, ... }, subs => [ @proxied_subroutine_names ]; The "importing" option needs to be a hash or array reference with package names to be "use"d as keys, and array references containing the import arguments as values. These packages will be imported into every new variant, and need to set up every declarative subroutine you require to build your variable package. The next option will allow you to use these functions. See "importing" for more options. You can omit empty import argument lists when passing an array reference. The "subs" option is an array reference of subroutine names that are exported by the packages specified with "importing". These subroutines will be proxied from your declaration package to the variant to be generated. With "importing" initializing your package and "subs" declaring what subroutines you want to use to build a variant, you can now write a "make_variant" method building your variants. Declaring a method to produce variants Every time a user requests a new variant a method named "make_variant" will be called with the name of the target package and the arguments from the user. It can then use the proxied subroutines declared with "subs" to customize the new package. An "install" subroutine is exported as well allowing you to dynamically install methods into the new package. If these options aren't flexible enough, you can use the passed name of the new package to do any other kind of customizations. sub make_variant { my ($class, $target, @arguments) = @_; # ... # customization goes here # ... } When the method is finished, the user will receive the name of the new package variant you just set up. Using variable packages After your variable package is created your users can get a variant generating subroutine by simply importing your package. use My::Variant; my $new_variant_package = Variant(@variant_arguments); The package is now fully initialized and used. You can import the subroutine under a different name by specifying an "as" argument. Dynamic creation of variant packages For regular uses, the normal import provides more than enough flexibility. However, if you want to create variations of dynamically determined packages, you can use the "build_variant_of" method. You can use this to create variations of other packages and pass arguments on to them to allow more modular and extensible variations. OPTIONS These are the options that can be passed when importing "Package::Variant". They describe the environment in which the variants are created. use Package::Variant importing => { $package => \@import_arguments, ... }, subs => [ @proxied_subroutines ]; importing This option is a hash reference mapping package names to array references containing import arguments. The packages will be imported with the given arguments by every variation before the "make_variant" method is asked to create the package (this is done using Import::Into). If import order is important to you, you can also pass the "importing" arguments as a flat array reference: use Package::Variant importing => [ 'PackageA', 'PackageB' ]; # same as use Package::Variant importing => [ 'PackageA' => [], 'PackageB' => [] ]; # or use Package::Variant importing => { 'PackageA' => [], 'PackageB' => [] }; The import method will be called even if the list of import arguments is empty or not specified, If you just want to import a single package's default exports, you can also pass a string instead: use Package::Variant importing => 'Package'; subs An array reference of strings listing the names of subroutines that should be proxied. These subroutines are expected to be installed into the new variant package by the modules imported with "importing". Subroutines with the same name will be availabe in your declaration package, and will proxy through to the newly created package when used within "make_variant". VARIABLE PACKAGE METHODS These are methods on the variable package you declare when you import "Package::Variant". make_variant Some::Variant::Package->make_variant( $target, @arguments ); You need to provide this method. This method will be called for every new variant of your package. This method should use the subroutines declared in "subs" to customize the new variant package. This is a class method receiving the $target package and the @arguments defining the requested variant. import use Some::Variant::Package; my $variant_package = Package( @arguments ); This method is provided for you. It will allow a user to "use" your package and receive a subroutine taking @arguments defining the variant and returning the name of the newly created variant package. The following options can be specified when importing: * as use Some::Variant::Package as => 'Foo'; my $variant_package = Foo(@arguments); Exports the generator subroutine under a different name than the default. "Package::Variant" METHODS These methods are available on "Package::Variant" itself. build_variant_of my $variant_package = Package::Variant ->build_variant_of($variable_package, @arguments); This is the dynamic method of creating new variants. It takes the $variable_package, which is a pre-declared variable package, and a set of @arguments passed to the package to generate a new $variant_package, which will be returned. import use Package::Variant @options; Sets up the environment in which you declare the variants of your packages. See "OPTIONS" for details on the available options and "EXPORTS" for a list of exported subroutines. EXPORTS Additionally to the proxies for subroutines provided in "subs", the following exports will be available in your variable package: install install($method_name, $code_reference); Installs a method with the given $method_name into the newly created variant package. The $code_reference will be used as the body for the method, and if Sub::Name is available the coderef will be named. If you want to name it something else, then use: install($method_name, $name_to_use, $code_reference); AUTHOR mst - Matt S. Trout (cpan:MSTROUT) CONTRIBUTORS phaylon - Robert Sedlacek (cpan:PHAYLON) COPYRIGHT Copyright (c) 2010-2012 the "Package::Variant" "AUTHOR" and "CONTRIBUTORS" as listed above. LICENSE This library is free software and may be distributed under the same terms as perl itself. Package-Variant-1.001004/t/000755 000767 000024 00000000000 12141235225 015410 5ustar00etherstaff000000 000000 Package-Variant-1.001004/t/01simple.t000644 000767 000024 00000006574 12124217651 017247 0ustar00etherstaff000000 000000 use strictures 1; use Test::More; use Test::Fatal; use Package::Variant (); my @DECLARED; BEGIN { package TestSugar; use Exporter 'import'; our @EXPORT_OK = qw( declare ); sub declare { push @DECLARED, [@_] } $INC{'TestSugar.pm'} = __FILE__; } BEGIN { package TestVariable; use Package::Variant importing => { 'TestSugar' => [qw( declare )] }, subs => [qw( declare )]; sub make_variant { my ($class, $target, @args) = @_; ::ok(__PACKAGE__->can('install'), 'install() is available') or ::BAIL_OUT('install() subroutine was not exported!'); ::ok(__PACKAGE__->can('declare'), 'declare() import is available') or ::BAIL_OUT('proxy declare() subroutine was not exported!'); declare target => $target; declare args => [@args]; declare class => $class->_test_class_method; install target => sub { $target }; install args => sub { [@args] }; } sub _test_class_method { return shift; } $INC{'TestVariable.pm'} = __FILE__; } my $variant = do { package TestScopeA; use TestVariable; TestVariable(3..7); }; ok defined($variant), 'new variant is a defined value'; ok length($variant), 'new variant has length'; is $variant->target, $variant, 'target was new variant'; is_deeply $variant->args, [3..7], 'correct arguments received'; is_deeply shift(@DECLARED), [target => $variant], 'target passed via proxy'; is_deeply shift(@DECLARED), [args => [3..7]], 'arguments passed via proxy'; is_deeply shift(@DECLARED), [class => 'TestVariable'], 'class method resolution'; is scalar(@DECLARED), 0, 'proxy sub called right amount of times'; use TestVariable as => 'RenamedVar'; is exception { my $renamed = RenamedVar(9..12); is_deeply $renamed->args, [9..12], 'imported generator can be renamed'; }, undef, 'no errors for renamed usage'; my @imported; BEGIN { package TestImportableA; sub import { push @imported, shift } $INC{'TestImportableA.pm'} = __FILE__; package TestImportableB; sub import { push @imported, shift } $INC{'TestImportableB.pm'} = __FILE__; package TestArrayImports; use Package::Variant importing => [ 'TestImportableA', 'TestImportableB', ]; sub make_variant { } $INC{'TestArrayImports.pm'} = __FILE__; } use TestArrayImports; TestArrayImports(23); is_deeply [@imported], [qw( TestImportableA TestImportableB )], 'multiple imports in the right order'; BEGIN { package TestSingleImport; use Package::Variant importing => 'TestImportableA'; sub make_variant { } $INC{'TestSingleImport.pm'} = __FILE__; } @imported = (); use TestSingleImport; TestSingleImport(23); is_deeply [@imported], [qw( TestImportableA )], 'scalar import works'; like exception { Package::Variant->import( importing => \'foo', subs => [qw( foo )], ); }, qr/importing.+option.+hash.+array/i, 'invalid "importing" option'; like exception { Package::Variant->import( importing => { foo => \'bar' }, subs => [qw( bar )], ); }, qr/import.+argument.+foo.+not.+array/i, 'invalid import argument list'; like exception { Package::Variant->import( importing => [ foo => ['bar'], ['bam'], subs => [qw( bar )] ], ); }, qr/value.+3.+importing.+not.+string/i, 'importing array invalid key'; like exception { Package::Variant->import( importing => [ foo => \'bam', subs => [qw( bar )] ], ); }, qr/value.+2.+foo.+importing.+array/i, 'importing array invalid list'; done_testing; Package-Variant-1.001004/t/10argument-types.t000644 000767 000024 00000001032 12124217651 020722 0ustar00etherstaff000000 000000 use strictures 1; use Test::More; BEGIN { package TestVariable; use Package::Variant; sub make_variant { my ($class, $target, @args) = @_; install variant_values => sub { [@args] }; } $INC{'TestVariable.pm'} = __FILE__; } use TestVariable; is_deeply TestVariable(23)->variant_values, [23], 'simple value argument'; is_deeply TestVariable(3..7)->variant_values, [3..7], 'multiple value arguments'; is_deeply TestVariable({ foo => 23 })->variant_values, [{ foo => 23 }], 'hash reference argument'; done_testing; Package-Variant-1.001004/t/11dynamic-build.t000644 000767 000024 00000000562 12124217651 020467 0ustar00etherstaff000000 000000 use strictures 1; use Test::More; BEGIN { package TestVariable; use Package::Variant; sub make_variant { my ($class, $target, @args) = @_; install variant_values => sub { [@args] }; } } is_deeply( Package::Variant ->build_variant_of('TestVariable', 3..7) ->variant_values, [3..7], 'build_variant_of with scalar values', ); done_testing; Package-Variant-1.001004/t/20moo-param-role.t000644 000767 000024 00000001547 12124217651 020601 0ustar00etherstaff000000 000000 use strictures 1; use Test::More; BEGIN { eval { require Moo::Role; 1 } or plan skip_all => q{Requires Moo::Role}; } BEGIN { package My::Role::OnOff; use Package::Variant importing => { 'Moo::Role' => [] }, subs => [ qw(has before after around) ]; sub make_variant { my ($me, $into, %args) = @_; my $name = $args{name}; has $name => (is => 'rw'); install "${name}_on" => sub { shift->$name(1); }; install "${name}_off" => sub { shift->$name(0); }; } $INC{"My/Role/OnOff.pm"} = __FILE__; } BEGIN { package LightSwitch; use My::Role::OnOff; use Moo; with OnOff(name => 'lights'); } my $lights = LightSwitch->new; is($lights->lights, undef, 'Initial state'); is($lights->lights_on, 1, 'Turn on'); is($lights->lights, 1, 'On'); is($lights->lights_off, 0, 'Turn off'); is($lights->lights, 0, 'Off'); done_testing; Package-Variant-1.001004/maint/Makefile.PL.include000644 000767 000024 00000000300 12124217651 021646 0ustar00etherstaff000000 000000 BEGIN { -e 'Distar' or system("git clone git://git.shadowcat.co.uk/p5sagit/Distar.git") } use lib "Distar/lib"; use Distar; author 'mst - Matt S. Trout (cpan:MSTROUT) '; Package-Variant-1.001004/lib/Package/000755 000767 000024 00000000000 12141235225 017246 5ustar00etherstaff000000 000000 Package-Variant-1.001004/lib/Package/Variant.pm000644 000767 000024 00000026610 12141235127 021216 0ustar00etherstaff000000 000000 package Package::Variant; use strictures 1; use Import::Into; use Module::Runtime qw(use_module); use Carp qw(croak); our $VERSION = '1.001004'; # 1.1.4 $VERSION = eval $VERSION; our %Variable; my $sanitize_importing = sub { my ($me, $spec) = @_; return [] unless defined $spec; my @specced = not(ref $spec) ? ($spec) : (ref($spec) eq 'ARRAY') ? (@$spec) : (ref($spec) eq 'HASH') ? (map { croak qq{The import argument list for '$_' is not an array ref} unless ref($spec->{$_}) eq 'ARRAY'; ($_ => $spec->{$_}); } sort keys %$spec) : croak q{The 'importing' option has to be either a hash or array ref}; my @imports; my $arg_count = 1; while (@specced) { my $key = shift @specced; croak qq{Value $arg_count in 'importing' is not a package string}, $arg_count unless defined($key) and not(ref $key); $arg_count++; my $import_args = (not(@specced) or (defined($specced[0]) and not ref($specced[0]))) ? [] : (ref($specced[0]) eq 'ARRAY') ? do { $arg_count++; shift @specced } : croak( qq{Value $arg_count for package '$key' in 'importing' is not} . qq{ a package string or array ref} ); push @imports, [$key, $import_args]; } return \@imports; }; my $sub_namer = eval { require Sub::Name; sub { shift if @_ > 2; Sub::Name::subname(@_) } } || sub { $_[-1] }; sub import { my $target = caller; my $me = shift; my $last = (split '::', $target)[-1]; my $anon = 'A000'; my $variable = $target; my %args = @_; no strict 'refs'; $Variable{$variable} = { anon => $anon, args => { %args, importing => $me->$sanitize_importing($args{importing}), }, subs => { map +($_ => sub {}), @{$args{subs}||[]}, }, }; *{"${target}::import"} = sub { my $target = caller; my (undef, %arg) = @_; my $as = defined($arg{as}) ? $arg{as} : $last; no strict 'refs'; *{"${target}::${as}"} = sub { $me->build_variant_of($variable, @_); }; }; my $subs = $Variable{$variable}{subs}; foreach my $name (keys %$subs) { *{"${target}::${name}"} = sub { goto &{$subs->{$name}} }; } *{"${target}::install"} = sub { goto &{$Variable{$variable}{install}}; } } sub build_variant_of { my ($me, $variable, @args) = @_; my $variant_name = "${variable}::_Variant_".++$Variable{$variable}{anon}; foreach my $to_import (@{$Variable{$variable}{args}{importing}}) { my ($pkg, $args) = @$to_import; use_module($pkg)->import::into($variant_name, @{$args}); } my $subs = $Variable{$variable}{subs}; local @{$subs}{keys %$subs} = map $variant_name->can($_), keys %$subs; local $Variable{$variable}{install} = sub { my $full_name = "${variant_name}::".shift; my $ref = $sub_namer->($full_name, @_); no strict 'refs'; *$full_name = $ref; }; $variable->make_variant($variant_name, @args); return $variant_name; } 1; __END__ =head1 NAME Package::Variant - Parameterizable packages =head1 SYNOPSIS # declaring a variable Moo role package My::Role::ObjectAttr; use strictures 1; use Package::Variant # what modules to 'use' importing => ['Moo::Role'], # proxied subroutines subs => [ qw(has around before after with) ], sub make_variant { my ($class, $target_package, %arguments) = @_; # access arguments my $name = $arguments{name}; # use proxied 'has' to add an attribute has $name => (is => 'lazy'); # install a builder method install "_build_${name}" => sub { return $arguments{class}->new; }; } # using the role package My::Class::WithObjectAttr; use strictures 1; use Moo; use My::Role::ObjectAttr; with ObjectAttr(name => 'some_obj', class => 'Some::Class'); # using our class my $obj = My::Class::WithObjectAttr->new; $obj->some_obj; # returns a Some::Class instance =head1 DESCRIPTION This module allows you to build packages that return different variations depending on what parameters are given. Users of your package will receive a subroutine able to take parameters and return the name of a suitable variant package. The implmenetation does not care about what kind of package it builds. =head2 Declaring a variable package There are two important parts to creating a variable package. You first have to give C some basic information about what kind of package you want to provide, and how. The second part is implementing a method receiving the user's arguments and generating your variants. =head3 Setting up the environment for building variations When you C, you pass along some arguments that describe how you intend to build your variations. use Package::Variant importing => { $package => \@import_arguments, ... }, subs => [ @proxied_subroutine_names ]; The L option needs to be a hash or array reference with package names to be Cd as keys, and array references containing the import arguments as values. These packages will be imported into every new variant, and need to set up every declarative subroutine you require to build your variable package. The next option will allow you to use these functions. See L for more options. You can omit empty import argument lists when passing an array reference. The L option is an array reference of subroutine names that are exported by the packages specified with L. These subroutines will be proxied from your declaration package to the variant to be generated. With L initializing your package and L declaring what subroutines you want to use to build a variant, you can now write a L method building your variants. =head3 Declaring a method to produce variants Every time a user requests a new variant a method named L will be called with the name of the target package and the arguments from the user. It can then use the proxied subroutines declared with L to customize the new package. An L subroutine is exported as well allowing you to dynamically install methods into the new package. If these options aren't flexible enough, you can use the passed name of the new package to do any other kind of customizations. sub make_variant { my ($class, $target, @arguments) = @_; # ... # customization goes here # ... } When the method is finished, the user will receive the name of the new package variant you just set up. =head2 Using variable packages After your variable package is L your users can get a variant generating subroutine by simply importing your package. use My::Variant; my $new_variant_package = Variant(@variant_arguments); The package is now fully initialized and used. You can import the subroutine under a different name by specifying an C argument. =head2 Dynamic creation of variant packages For regular uses, the L provides more than enough flexibility. However, if you want to create variations of dynamically determined packages, you can use the L method. You can use this to create variations of other packages and pass arguments on to them to allow more modular and extensible variations. =head1 OPTIONS These are the options that can be passed when importing C. They describe the environment in which the variants are created. use Package::Variant importing => { $package => \@import_arguments, ... }, subs => [ @proxied_subroutines ]; =head2 importing This option is a hash reference mapping package names to array references containing import arguments. The packages will be imported with the given arguments by every variation before the L method is asked to create the package (this is done using L). If import order is important to you, you can also pass the C arguments as a flat array reference: use Package::Variant importing => [ 'PackageA', 'PackageB' ]; # same as use Package::Variant importing => [ 'PackageA' => [], 'PackageB' => [] ]; # or use Package::Variant importing => { 'PackageA' => [], 'PackageB' => [] }; The import method will be called even if the list of import arguments is empty or not specified, If you just want to import a single package's default exports, you can also pass a string instead: use Package::Variant importing => 'Package'; =head2 subs An array reference of strings listing the names of subroutines that should be proxied. These subroutines are expected to be installed into the new variant package by the modules imported with L. Subroutines with the same name will be availabe in your declaration package, and will proxy through to the newly created package when used within L. =head1 VARIABLE PACKAGE METHODS These are methods on the variable package you declare when you import C. =head2 make_variant Some::Variant::Package->make_variant( $target, @arguments ); B This method will be called for every new variant of your package. This method should use the subroutines declared in L to customize the new variant package. This is a class method receiving the C<$target> package and the C<@arguments> defining the requested variant. =head2 import use Some::Variant::Package; my $variant_package = Package( @arguments ); This method is provided for you. It will allow a user to C your package and receive a subroutine taking C<@arguments> defining the variant and returning the name of the newly created variant package. The following options can be specified when importing: =over =item * B use Some::Variant::Package as => 'Foo'; my $variant_package = Foo(@arguments); Exports the generator subroutine under a different name than the default. =back =head1 C METHODS These methods are available on C itself. =head2 build_variant_of my $variant_package = Package::Variant ->build_variant_of($variable_package, @arguments); This is the dynamic method of creating new variants. It takes the C<$variable_package>, which is a pre-declared variable package, and a set of C<@arguments> passed to the package to generate a new C<$variant_package>, which will be returned. =head2 import use Package::Variant @options; Sets up the environment in which you declare the variants of your packages. See L for details on the available options and L for a list of exported subroutines. =head1 EXPORTS Additionally to the proxies for subroutines provided in L, the following exports will be available in your variable package: =head2 install install($method_name, $code_reference); Installs a method with the given C<$method_name> into the newly created variant package. The C<$code_reference> will be used as the body for the method, and if L is available the coderef will be named. If you want to name it something else, then use: install($method_name, $name_to_use, $code_reference); =head1 AUTHOR mst - Matt S. Trout (cpan:MSTROUT) =head1 CONTRIBUTORS phaylon - Robert Sedlacek (cpan:PHAYLON) =head1 COPYRIGHT Copyright (c) 2010-2012 the C L and L as listed above. =head1 LICENSE This library is free software and may be distributed under the same terms as perl itself. =cut