commit perl-Exporter-Declare for openSUSE:Factory

Hello community, here is the log from the commit of package perl-Exporter-Declare for openSUSE:Factory checked in at 2015-06-30 10:18:18 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/perl-Exporter-Declare (Old) and /work/SRC/openSUSE:Factory/.perl-Exporter-Declare.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "perl-Exporter-Declare" Changes: -------- --- /work/SRC/openSUSE:Factory/perl-Exporter-Declare/perl-Exporter-Declare.changes 2013-07-16 17:02:15.000000000 +0200 +++ /work/SRC/openSUSE:Factory/.perl-Exporter-Declare.new/perl-Exporter-Declare.changes 2015-06-30 10:18:22.000000000 +0200 @@ -1,0 +2,6 @@ +Sat Jun 27 08:33:02 UTC 2015 - coolo@suse.com + +- updated to 0.114 + see /usr/share/doc/packages/perl-Exporter-Declare/ + +------------------------------------------------------------------- Old: ---- Exporter-Declare-0.113.tar.gz New: ---- Exporter-Declare-0.114.tar.gz cpanspec.yml ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ perl-Exporter-Declare.spec ++++++ --- /var/tmp/diff_new_pack.pDg0qU/_old 2015-06-30 10:18:23.000000000 +0200 +++ /var/tmp/diff_new_pack.pDg0qU/_new 2015-06-30 10:18:23.000000000 +0200 @@ -1,7 +1,7 @@ # # spec file for package perl-Exporter-Declare # -# Copyright (c) 2013 SUSE LINUX Products GmbH, Nuernberg, Germany. +# Copyright (c) 2015 SUSE LINUX GmbH, Nuernberg, Germany. # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -17,34 +17,25 @@ Name: perl-Exporter-Declare -Version: 0.113 +Version: 0.114 Release: 0 %define cpan_name Exporter-Declare Summary: Exporting done right License: Artistic-1.0 or GPL-1.0+ Group: Development/Libraries/Perl Url: http://search.cpan.org/dist/Exporter-Declare/ -Source: http://www.cpan.org/authors/id/E/EX/EXODIST/%{cpan_name}-%{version}.tar.gz +Source0: http://www.cpan.org/authors/id/E/EX/EXODIST/%{cpan_name}-%{version}.tar.gz +Source1: cpanspec.yml BuildArch: noarch BuildRoot: %{_tmppath}/%{name}-%{version}-build BuildRequires: perl BuildRequires: perl-macros BuildRequires: perl(Fennec::Lite) >= 0.004 BuildRequires: perl(Meta::Builder) >= 0.003 -BuildRequires: perl(Module::Build) >= 0.40 -BuildRequires: perl(Test::Exception) >= 0.29 +BuildRequires: perl(Module::Build) >= 0.420000 +BuildRequires: perl(Test::Exception) >= 0.290000 BuildRequires: perl(Test::Simple) >= 0.88 BuildRequires: perl(aliased) -#BuildRequires: perl(Exporter::Declare) -#BuildRequires: perl(Exporter::Declare::Export) -#BuildRequires: perl(Exporter::Declare::Export::Alias) -#BuildRequires: perl(Exporter::Declare::Export::Generator) -#BuildRequires: perl(Exporter::Declare::Export::Sub) -#BuildRequires: perl(Exporter::Declare::Export::Variable) -#BuildRequires: perl(Exporter::Declare::Magic) -#BuildRequires: perl(Exporter::Declare::Meta) -#BuildRequires: perl(Exporter::Declare::Specs) -#BuildRequires: perl(InheritanceParent) Requires: perl(Meta::Builder) >= 0.003 Requires: perl(aliased) %{perl_requires} @@ -72,6 +63,6 @@ %files -f %{name}.files %defattr(-,root,root,755) -%doc Changes README +%doc README %changelog ++++++ Exporter-Declare-0.113.tar.gz -> Exporter-Declare-0.114.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Exporter-Declare-0.113/Changes new/Exporter-Declare-0.114/Changes --- old/Exporter-Declare-0.113/Changes 2013-06-07 05:35:24.000000000 +0200 +++ new/Exporter-Declare-0.114/Changes 1970-01-01 01:00:00.000000000 +0100 @@ -1,10 +0,0 @@ -WARNING: This file is very likely to get out of date, I almost never remeber to -update it. - -0.111: - * Fix broken inheritance, better fix for UNIVERAL::can sillyness - -0.110: - * Fixed 'can() used as function' warning that sometimes happens - * Fixed brocken magic.t unit test - diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Exporter-Declare-0.113/MANIFEST new/Exporter-Declare-0.114/MANIFEST --- old/Exporter-Declare-0.113/MANIFEST 2013-06-07 05:35:24.000000000 +0200 +++ new/Exporter-Declare-0.114/MANIFEST 2015-06-23 23:01:46.000000000 +0200 @@ -1,5 +1,4 @@ Build.PL -Changes lib/Exporter/Declare.pm lib/Exporter/Declare/Export.pm lib/Exporter/Declare/Export/Alias.pm @@ -12,6 +11,7 @@ META.json META.yml README +README.pod t/Declare.t t/Export.t t/Generator.t diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Exporter-Declare-0.113/META.json new/Exporter-Declare-0.114/META.json --- old/Exporter-Declare-0.113/META.json 2013-06-07 05:35:24.000000000 +0200 +++ new/Exporter-Declare-0.114/META.json 2015-06-23 23:01:46.000000000 +0200 @@ -4,7 +4,7 @@ "Chad Granum " ], "dynamic_config" : 1, - "generated_by" : "Module::Build version 0.4003, CPAN::Meta::Converter version 2.120921", + "generated_by" : "Module::Build version 0.4212", "license" : [ "perl_5" ], @@ -23,7 +23,7 @@ }, "configure" : { "requires" : { - "Module::Build" : "0.40" + "Module::Build" : "0.42" } }, "runtime" : { @@ -39,35 +39,28 @@ "provides" : { "Exporter::Declare" : { "file" : "lib/Exporter/Declare.pm", - "version" : "0.113" + "version" : "0.114" }, "Exporter::Declare::Export" : { - "file" : "lib/Exporter/Declare/Export.pm", - "version" : 0 + "file" : "lib/Exporter/Declare/Export.pm" }, "Exporter::Declare::Export::Alias" : { - "file" : "lib/Exporter/Declare/Export/Alias.pm", - "version" : 0 + "file" : "lib/Exporter/Declare/Export/Alias.pm" }, "Exporter::Declare::Export::Generator" : { - "file" : "lib/Exporter/Declare/Export/Generator.pm", - "version" : 0 + "file" : "lib/Exporter/Declare/Export/Generator.pm" }, "Exporter::Declare::Export::Sub" : { - "file" : "lib/Exporter/Declare/Export/Sub.pm", - "version" : 0 + "file" : "lib/Exporter/Declare/Export/Sub.pm" }, "Exporter::Declare::Export::Variable" : { - "file" : "lib/Exporter/Declare/Export/Variable.pm", - "version" : 0 + "file" : "lib/Exporter/Declare/Export/Variable.pm" }, "Exporter::Declare::Meta" : { - "file" : "lib/Exporter/Declare/Meta.pm", - "version" : 0 + "file" : "lib/Exporter/Declare/Meta.pm" }, "Exporter::Declare::Specs" : { - "file" : "lib/Exporter/Declare/Specs.pm", - "version" : 0 + "file" : "lib/Exporter/Declare/Specs.pm" } }, "release_status" : "stable", @@ -83,5 +76,5 @@ "url" : "http://github.com/exodist/Exporter-Declare" } }, - "version" : "0.113" + "version" : "0.114" } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Exporter-Declare-0.113/META.yml new/Exporter-Declare-0.114/META.yml --- old/Exporter-Declare-0.113/META.yml 2013-06-07 05:35:24.000000000 +0200 +++ new/Exporter-Declare-0.114/META.yml 2015-06-23 23:01:46.000000000 +0200 @@ -3,52 +3,45 @@ author: - 'Chad Granum ' build_requires: - Fennec::Lite: 0.004 - Test::Exception: 0.29 - Test::Simple: 0.88 + Fennec::Lite: '0.004' + Test::Exception: '0.29' + Test::Simple: '0.88' configure_requires: - Module::Build: 0.40 + Module::Build: '0.42' dynamic_config: 1 -generated_by: 'Module::Build version 0.4003, CPAN::Meta::Converter version 2.120921' +generated_by: 'Module::Build version 0.4212, CPAN::Meta::Converter version 2.150001' license: perl meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html - version: 1.4 + version: '1.4' name: Exporter-Declare provides: Exporter::Declare: file: lib/Exporter/Declare.pm - version: 0.113 + version: '0.114' Exporter::Declare::Export: file: lib/Exporter/Declare/Export.pm - version: 0 Exporter::Declare::Export::Alias: file: lib/Exporter/Declare/Export/Alias.pm - version: 0 Exporter::Declare::Export::Generator: file: lib/Exporter/Declare/Export/Generator.pm - version: 0 Exporter::Declare::Export::Sub: file: lib/Exporter/Declare/Export/Sub.pm - version: 0 Exporter::Declare::Export::Variable: file: lib/Exporter/Declare/Export/Variable.pm - version: 0 Exporter::Declare::Meta: file: lib/Exporter/Declare/Meta.pm - version: 0 Exporter::Declare::Specs: file: lib/Exporter/Declare/Specs.pm - version: 0 requires: - Carp: 0 - Meta::Builder: 0.003 - Scalar::Util: 0 - aliased: 0 + Carp: '0' + Meta::Builder: '0.003' + Scalar::Util: '0' + aliased: '0' perl: v5.8.0 resources: bugtracker: http://github.com/exodist/Exporter-Declare/issues homepage: http://open-exodus.net/projects/Exporter-Declare license: http://dev.perl.org/licenses/ repository: http://github.com/exodist/Exporter-Declare -version: 0.113 +version: '0.114' diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Exporter-Declare-0.113/README new/Exporter-Declare-0.114/README --- old/Exporter-Declare-0.113/README 2013-06-07 05:35:24.000000000 +0200 +++ new/Exporter-Declare-0.114/README 2015-06-23 23:01:46.000000000 +0200 @@ -1,195 +1,216 @@ NAME + Exporter::Declare - Exporting done right DESCRIPTION + Exporter::Declare is a meta-driven exporting tool. Exporter::Declare tries to adopt all the good features of other exporting tools, while - throwing away horrible interfaces. Exporter::Declare also provides hooks - that allow you to add options and arguments for import. Finally, + throwing away horrible interfaces. Exporter::Declare also provides + hooks that allow you to add options and arguments for import. Finally, Exporter::Declare's meta-driven system allows for top-notch introspection. FEATURES + Declarative exporting (like Moose for exporting) + Meta-driven for introspection + Customizable import() method + Export groups (tags) + Export generators for subs and variables + Clear and concise OO API + Exports are blessed, allowing for more introspection + Import syntax based off of Sub::Exporter + Packages export aliases SYNOPSIS - EXPORTER + + EXPORTER + package Some::Exporter; use Exporter::Declare; - + default_exports qw/ do_the_thing /; exports qw/ subA subB $SCALAR @ARRAY %HASH /; - + # Create a couple tags (import lists) export_tag subs => qw/ subA subB do_the_thing /; export_tag vars => qw/ $SCALAR @ARRAY %HASH /; - + # These are simple boolean options, pass '-optionA' to enable it. import_options qw/ optionA optionB /; - + # These are options which slurp in the next argument as their value, pass # '-optionC' => 'foo' to give it a value. import_arguments qw/ optionC optionD /; - + export anon_export => sub { ... }; export '@anon_var' => [...]; - + default_export a_default => sub { 'default!' } - + our $X = "x"; default_export '$X'; - + my $iterator = 'a'; gen_export unique_class_id => sub { my $current = $iterator++; return sub { $current }; }; - + gen_default_export '$my_letter' => sub { my $letter = $iterator++; return \$letter; }; - + # You can create a function to mangle the arguments before they are # parsed into a Exporter::Declare::Spec object. sub alter_import_args { - my ($class, $args) = @_; - + my ($class, $importer, $args) = @_; + # fiddle with args before importing routines are called @$args = grep { !/^skip_/ } @$args } - + # There is no need to fiddle with import() or do any wrapping. # the $specs data structure means you generally do not need to parse # arguments yourself (but you can if you want using alter_import_args()) - + # Change the spec object before export occurs sub before_import { my $class = shift; my ( $importer, $specs ) = @_; - + if ($specs->config->{optionA}) { # Modify $spec attributes accordingly } } - + # Use spec object after export occurs sub after_import { my $class = shift; my ( $importer, $specs ) = @_; - + do_option_a() if $specs->config->{optionA}; - + do_option_c( $specs->config->{optionC} ) if $specs->config->{optionC}; - + print "-subs tag was used\n" if $specs->config->{subs}; - + print "exported 'subA'\n" if $specs->exports->{subA}; } - + ... - IMPORTER + IMPORTER + package Some::Importer; use Some::Exporter qw/ subA $SCALAR !%HASH /, -default => { -prefix => 'my_' }, qw/ -optionA !-optionB /, subB => { -as => 'sub_b' }; - + subA(); print $SCALAR; sub_b(); my_do_the_thing(); - + ... IMPORT INTERFACE - Importing from a package that uses Exporter::Declare will be familiar to - anyone who has imported from modules before. Arguments are all assumed - to be export names, unless prefixed with "-" or ":" In which case they - may be a tag or an option. Exports without a sigil are assumed to be - code exports, variable exports must be listed with their sigil. - Items prefixed with the "!" symbol are forcfully excluded, regardless of + Importing from a package that uses Exporter::Declare will be familiar + to anyone who has imported from modules before. Arguments are all + assumed to be export names, unless prefixed with - or : In which case + they may be a tag or an option. Exports without a sigil are assumed to + be code exports, variable exports must be listed with their sigil. + + Items prefixed with the ! symbol are forcefully excluded, regardless of any listed item that may normally include them. Tags can also be excluded, this will effectively exclude everything in the tag. Tags are simply lists of exports, the exporting class may define any number of tags. Exporter::Declare also has the concept of options, they have the same syntax as tags. Options may be boolean or argument based. - Boolean options are actually 3 value, undef, false "!", or true. - Argument based options will grab the next value in the arguments list as - their own, regardless of what type of value it is. + Boolean options are actually 3 value, undef, false !, or true. Argument + based options will grab the next value in the arguments list as their + own, regardless of what type of value it is. When you use the module, or call import(), all the arguments are transformed into an Exporter::Declare::Specs object. Arguments are - parsed for you into a list of imports, and a configuration hash in which - tags/options are keys. Tags are listed in the config hash as true, - false, or undef depending on if they were included, negated, or + parsed for you into a list of imports, and a configuration hash in + which tags/options are keys. Tags are listed in the config hash as + true, false, or undef depending on if they were included, negated, or unlisted. Boolean options will be treated in the same way as tags. Options that take arguments will have the argument as their value. - SELECTING ITEMS TO IMPORT + SELECTING ITEMS TO IMPORT + Exports can be subs, or package variables (scalar, hash, array). For subs simply ask for the sub by name, you may optionally prefix the subs - name with the sub sigil "&". For variables list the variable name along - with its sigil "$, %, or @". + name with the sub sigil &. For variables list the variable name along + with its sigil $, %, or @. use Some::Exporter qw/ somesub $somescalar %somehash @somearray /; - TAGS + TAGS + Every exporter automatically has the following 3 tags, in addition they may define any number of custom tags. Tags can be specified by their - name prefixed by either "-" or ":". + name prefixed by either - or :. -all - This tag may be used to import everything the exporter provides. + + This tag may be used to import everything the exporter provides. -default - This tag is used to import the default items exported. This will be - used when no argument is provided to import. - -alias - Every package has an alias that it can export. This is the last - segmant of the packages namespace. IE "My::Long::Package::Name::Foo" - could export the "Foo()" function. These alias functionis simply - return the full package name as a string, in this case - 'My::Long::Package::Name::Foo'. This is similar to aliased. + This tag is used to import the default items exported. This will be + used when no argument is provided to import. - The -alias tag is a shortcut so that you do not need to think about - what the alias name would be when adding it to the import arguments. + -alias - use My::Long::Package::Name::Foo -alias; + Every package has an alias that it can export. This is the last + segment of the packages namespace. IE My::Long::Package::Name::Foo + could export the Foo() function. These alias functions simply return + the full package name as a string, in this case + 'My::Long::Package::Name::Foo'. This is similar to aliased. + + The -alias tag is a shortcut so that you do not need to think about + what the alias name would be when adding it to the import arguments. + + use My::Long::Package::Name::Foo -alias; + + my $foo = Foo()->new(...); - my $foo = Foo()->new(...); + RENAMING IMPORTED ITEMS - RENAMING IMPORTED ITEMS You can prefix, suffix, or completely rename the items you import. Whenever an item is followed by a hash in the import list, that hash will be used for configuration. Configuration items always start with a - dash "-". + dash -. The 3 available configuration options that effect import names are - "-prefix", "-suffix", and "-as". If "-as" is seen it will be used as is. - If prefix or suffix are seen they will be attached to the original name + -prefix, -suffix, and -as. If -as is seen it will be used as is. If + prefix or suffix are seen they will be attached to the original name (unless -as is present in which case they are ignored). use Some::Exporter subA => { -as => 'DoThing' }, subB => { -prefix => 'my_', -suffix => '_ok' }; - The example above will import "subA()" under the name "DoThing()". It - will also import "subB()" under the name "my_subB_ok()". + The example above will import subA() under the name DoThing(). It will + also import subB() under the name my_subB_ok(). You may als specify a prefix and/or suffix for tags. The following example will import all the default exports with 'my_' prefixed to each @@ -197,14 +218,16 @@ use Some::Exporter -default => { -prefix => 'my_' }; - OPTIONS + OPTIONS + Some exporters will recognise options. Options look just like tags, and are specified the same way. What options do, and how they effect things is exporter-dependant. use Some::Exporter qw/ -optionA -optionB /; - ARGUMENTS + ARGUMENTS + Some options require an argument. These options are just like other tags/options except that the next item in the argument list is slurped in as the option value. @@ -214,7 +237,8 @@ Once again available options are exporter specific. - PROVIDING ARGUMENTS FOR GENERATED ITEMS + PROVIDING ARGUMENTS FOR GENERATED ITEMS + Some items are generated at import time. These items may accept arguments. There are 3 ways to provide arguments, and they may all be mixed (though that is not recommended). @@ -231,80 +255,102 @@ use Some::Exporter generated => { -as => 'my_gen', -args => [ 'arg1', ... ]}; - You can use all three at once, but this is really a bad idea, documented - for completeness: + You can use all three at once, but this is really a bad idea, + documented for completeness: use Some::Exporter generated => { -as => 'my_gen, key => 'value', -args => [ 'arg1', 'arg2' ]} generated => [ 'arg3', 'arg4' ]; The example above will work fine, all the arguments will make it into the generator. The only valid reason for this to work is that you may - provide arguments such as "-prefix" to a tag that brings in generator(), - while also desiring to give arguments to generator() independantly. + provide arguments such as -prefix to a tag that brings in generator(), + while also desiring to give arguments to generator() independently. PRIMARY EXPORT API + With the exception of import(), all the following work equally well as functions or class methods. import( @args ) - The import() class method. This turns the @args list into an - Exporter::Declare::Specs object. + + The import() class method. This turns the @args list into an + Exporter::Declare::Specs object. exports( @add_items ) - Add items to be exported. + + Add items to be exported. @list = exports() - Retrieve list of exports. + + Retrieve list of exports. default_exports( @add_items ) - Add items to be exported, and add them to the -default tag. + + Add items to be exported, and add them to the -default tag. @list = default_exports() - List of exports in the -default tag + + List of exports in the -default tag import_options(@add_items) - Specify boolean options that should be accepted at import time. + + Specify boolean options that should be accepted at import time. import_arguments(@add_items) - Specify options that should be accepted at import that take - arguments. + + Specify options that should be accepted at import that take + arguments. export_tag( $name, @add_items ); - Define an export tag, or add items to an existing tag. + + Define an export tag, or add items to an existing tag. EXTENDED EXPORT API - These all work fine in function or method form, however the syntax sugar - will only work in function form. + + These all work fine in function or method form, however the syntax + sugar will only work in function form. reexport( $package ) - Make this exporter inherit all the exports and tags of $package. - Works for Exporter::Declare or Exporter.pm based exporters. - Re-Exporting of Sub::Exporter based classes is not currently - supported. + + Make this exporter inherit all the exports and tags of $package. + Works for Exporter::Declare or Exporter.pm based exporters. + Re-Exporting of Sub::Exporter based classes is not currently + supported. export_to( $package, @args ) - Export to the specified class. + + Export to the specified class. export( $name ) + export( $name, $ref ) - export is a keyword that lets you export any 1 item at a time. The - item can be exported by name, or name + ref. When a ref is provided, - the export is created, but there is no corresponding variable/sub in - the packages namespace. + + export is a keyword that lets you export any 1 item at a time. The + item can be exported by name, or name + ref. When a ref is provided, + the export is created, but there is no corresponding variable/sub in + the packages namespace. default_export( $name ) + default_export( $name, $ref ) + gen_export( $name ) + gen_export( $name, $ref ) + gen_default_export( $name ) + gen_default_export( $name, $ref ) - These all act just like export(), except that they add subrefs as - generators, and/or add exports to the -default tag. + + These all act just like export(), except that they add subrefs as + generators, and/or add exports to the -default tag. MAGIC + Please use Exporter::Declare::Magic directly from now on. - DEPRECATED USAGE OF MAGIC + DEPRECATED USAGE OF MAGIC + use Exporter::Declare '-magic'; This adds Devel::Declare magic to several functions. It also allows you @@ -317,29 +363,33 @@ use Exporter::Declare -magic => [ '-default', '!export', -prefix => 'magic_' ]; INTERNAL API + Exporter/Declare.pm does not have much logic to speak of. Rather Exporter::Declare is sugar on top of class meta data stored in Exporter::Declare::Meta objects. Arguments are parsed via - Exporter::Declare::Specs, and also turned into objects. Even exports are - blessed references to the exported item itself, and handle the injection - on their own (See Exporter::Declare::Export). + Exporter::Declare::Specs, and also turned into objects. Even exports + are blessed references to the exported item itself, and handle the + injection on their own (See Exporter::Declare::Export). META CLASS + All exporters have a meta class, the only way to get the meta object is - to call the exporter_meta() method on the class/object that is an + to call the export_meta() method on the class/object that is an exporter. Any class that uses Exporter::Declare gets this method, and a meta-object. AUTHORS + Chad Granum exodist7@gmail.com COPYRIGHT + Copyright (C) 2010 Chad Granum Exporter-Declare is free software; Standard perl licence. Exporter-Declare is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the license for - more details. + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the license + for more details. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Exporter-Declare-0.113/README.pod new/Exporter-Declare-0.114/README.pod --- old/Exporter-Declare-0.113/README.pod 1970-01-01 01:00:00.000000000 +0100 +++ new/Exporter-Declare-0.114/README.pod 2015-06-23 23:01:46.000000000 +0200 @@ -0,0 +1,401 @@ +=head1 NAME + +Exporter::Declare - Exporting done right + +=head1 DESCRIPTION + +Exporter::Declare is a meta-driven exporting tool. Exporter::Declare tries to +adopt all the good features of other exporting tools, while throwing away +horrible interfaces. Exporter::Declare also provides hooks that allow you to add +options and arguments for import. Finally, Exporter::Declare's meta-driven +system allows for top-notch introspection. + +=head1 FEATURES + +=over 4 + +=item Declarative exporting (like L<Moose> for exporting) + +=item Meta-driven for introspection + +=item Customizable import() method + +=item Export groups (tags) + +=item Export generators for subs and variables + +=item Clear and concise OO API + +=item Exports are blessed, allowing for more introspection + +=item Import syntax based off of LSub::Exporter + +=item Packages export aliases + +=back + +=head1 SYNOPSIS + +=head2 EXPORTER + + package Some::Exporter; + use Exporter::Declare; + + default_exports qw/ do_the_thing /; + exports qw/ subA subB $SCALAR @ARRAY %HASH /; + + # Create a couple tags (import lists) + export_tag subs => qw/ subA subB do_the_thing /; + export_tag vars => qw/ $SCALAR @ARRAY %HASH /; + + # These are simple boolean options, pass '-optionA' to enable it. + import_options qw/ optionA optionB /; + + # These are options which slurp in the next argument as their value, pass + # '-optionC' => 'foo' to give it a value. + import_arguments qw/ optionC optionD /; + + export anon_export => sub { ... }; + export '@anon_var' => [...]; + + default_export a_default => sub { 'default!' } + + our $X = "x"; + default_export '$X'; + + my $iterator = 'a'; + gen_export unique_class_id => sub { + my $current = $iterator++; + return sub { $current }; + }; + + gen_default_export '$my_letter' => sub { + my $letter = $iterator++; + return \$letter; + }; + + # You can create a function to mangle the arguments before they are + # parsed into a Exporter::Declare::Spec object. + sub alter_import_args { + my ($class, $args) = @_; + + # fiddle with args before importing routines are called + @$args = grep { !/^skip_/ } @$args + } + + # There is no need to fiddle with import() or do any wrapping. + # the $specs data structure means you generally do not need to parse + # arguments yourself (but you can if you want using alter_import_args()) + + # Change the spec object before export occurs + sub before_import { + my $class = shift; + my ( $importer, $specs ) = @_; + + if ($specs->config->{optionA}) { + # Modify $spec attributes accordingly + } + } + + # Use spec object after export occurs + sub after_import { + my $class = shift; + my ( $importer, $specs ) = @_; + + do_option_a() if $specs->config->{optionA}; + + do_option_c( $specs->config->{optionC} ) + if $specs->config->{optionC}; + + print "-subs tag was used\n" + if $specs->config->{subs}; + + print "exported 'subA'\n" + if $specs->exports->{subA}; + } + + ... + +=head2 IMPORTER + + package Some::Importer; + use Some::Exporter qw/ subA $SCALAR !%HASH /, + -default => { -prefix => 'my_' }, + qw/ -optionA !-optionB /, + subB => { -as => 'sub_b' }; + + subA(); + print $SCALAR; + sub_b(); + my_do_the_thing(); + + ... + +=head1 IMPORT INTERFACE + +Importing from a package that uses Exporter::Declare will be familiar to anyone +who has imported from modules before. Arguments are all assumed to be export +names, unless prefixed with C<-> or C<:> In which case they may be a tag or an +option. Exports without a sigil are assumed to be code exports, variable +exports must be listed with their sigil. + +Items prefixed with the C symbol are forcefully excluded, regardless of any +listed item that may normally include them. Tags can also be excluded, this +will effectively exclude everything in the tag. + +Tags are simply lists of exports, the exporting class may define any number of +tags. Exporter::Declare also has the concept of options, they have the same +syntax as tags. Options may be boolean or argument based. Boolean options are +actually 3 value, undef, false C, or true. Argument based options will grab +the next value in the arguments list as their own, regardless of what type of +value it is. + +When you use the module, or call import(), all the arguments are transformed +into an LExporter::Declare::Specs object. Arguments are parsed for you into a +list of imports, and a configuration hash in which tags/options are keys. Tags +are listed in the config hash as true, false, or undef depending on if they +were included, negated, or unlisted. Boolean options will be treated in the +same way as tags. Options that take arguments will have the argument as their +value. + +=head2 SELECTING ITEMS TO IMPORT + +Exports can be subs, or package variables (scalar, hash, array). For subs +simply ask for the sub by name, you may optionally prefix the subs name with +the sub sigil C<&>. For variables list the variable name along with its sigil +C<$, %, or @>. + + use Some::Exporter qw/ somesub $somescalar %somehash @somearray /; + +=head2 TAGS + +Every exporter automatically has the following 3 tags, in addition they may +define any number of custom tags. Tags can be specified by their name prefixed +by either C<-> or C<:>. + +=over 4 + +=item -all + +This tag may be used to import everything the exporter provides. + +=item -default + +This tag is used to import the default items exported. This will be used when +no argument is provided to import. + +=item -alias + +Every package has an alias that it can export. This is the last segment of the +packages namespace. IE CMy::Long::Package::Name::Foo could export the C +function. These alias functions simply return the full package name as a +string, in this case C<'My::Long::Package::Name::Foo'>. This is similar to +L<aliased>. + +The -alias tag is a shortcut so that you do not need to think about what the +alias name would be when adding it to the import arguments. + + use My::Long::Package::Name::Foo -alias; + + my $foo = Foo()->new(...); + +=back + +=head2 RENAMING IMPORTED ITEMS + +You can prefix, suffix, or completely rename the items you import. Whenever an +item is followed by a hash in the import list, that hash will be used for +configuration. Configuration items always start with a dash C<->. + +The 3 available configuration options that effect import names are C<-prefix>, +C<-suffix>, and C<-as>. If C<-as> is seen it will be used as is. If prefix or +suffix are seen they will be attached to the original name (unless -as is +present in which case they are ignored). + + use Some::Exporter subA => { -as => 'DoThing' }, + subB => { -prefix => 'my_', -suffix => '_ok' }; + +The example above will import C under the name C. It will +also import C under the name C. + +You may als specify a prefix and/or suffix for tags. The following example will +import all the default exports with 'my_' prefixed to each name. + + use Some::Exporter -default => { -prefix => 'my_' }; + +=head2 OPTIONS + +Some exporters will recognise options. Options look just like tags, and are +specified the same way. What options do, and how they effect things is +exporter-dependant. + + use Some::Exporter qw/ -optionA -optionB /; + +=head2 ARGUMENTS + +Some options require an argument. These options are just like other +tags/options except that the next item in the argument list is slurped in as +the option value. + + use Some::Exporter -ArgOption => 'Value, not an export', + -ArgTakesHash => { ... }; + +Once again available options are exporter specific. + +=head2 PROVIDING ARGUMENTS FOR GENERATED ITEMS + +Some items are generated at import time. These items may accept arguments. +There are 3 ways to provide arguments, and they may all be mixed (though that +is not recommended). + +As a hash + + use Some::Exporter generated => { key => 'val', ... }; + +As an array + + use Some::Exporter generated => [ 'Arg1', 'Arg2', ... ]; + +As an array in a config hash + + use Some::Exporter generated => { -as => 'my_gen', -args => [ 'arg1', ... ]}; + +You can use all three at once, but this is really a bad idea, documented for completeness: + + use Some::Exporter generated => { -as => 'my_gen, key => 'value', -args => [ 'arg1', 'arg2' ]} + generated => [ 'arg3', 'arg4' ]; + +The example above will work fine, all the arguments will make it into the +generator. The only valid reason for this to work is that you may provide +arguments such as C<-prefix> to a tag that brings in generator(), while also +desiring to give arguments to generator() independently. + +=head1 PRIMARY EXPORT API + +With the exception of import(), all the following work equally well as +functions or class methods. + +=over 4 + +=item import( @args ) + +The import() class method. This turns the @args list into an +LExporter::Declare::Specs object. + +=item exports( @add_items ) + +Add items to be exported. + +=item @list = exports() + +Retrieve list of exports. + +=item default_exports( @add_items ) + +Add items to be exported, and add them to the -default tag. + +=item @list = default_exports() + +List of exports in the -default tag + +=item import_options(@add_items) + +Specify boolean options that should be accepted at import time. + +=item import_arguments(@add_items) + +Specify options that should be accepted at import that take arguments. + +=item export_tag( $name, @add_items ); + +Define an export tag, or add items to an existing tag. + +=back + +=head1 EXTENDED EXPORT API + +These all work fine in function or method form, however the syntax sugar will +only work in function form. + +=over 4 + +=item reexport( $package ) + +Make this exporter inherit all the exports and tags of $package. Works for +Exporter::Declare or Exporter.pm based exporters. Re-Exporting of +LSub::Exporter based classes is not currently supported. + +=item export_to( $package, @args ) + +Export to the specified class. + +=item export( $name ) + +=item export( $name, $ref ) + +export is a keyword that lets you export any 1 item at a time. The item can be +exported by name, or name + ref. When a ref is provided, the export is created, +but there is no corresponding variable/sub in the packages namespace. + +=item default_export( $name ) + +=item default_export( $name, $ref ) + +=item gen_export( $name ) + +=item gen_export( $name, $ref ) + +=item gen_default_export( $name ) + +=item gen_default_export( $name, $ref ) + +These all act just like export(), except that they add subrefs as generators, +and/or add exports to the -default tag. + +=back + +=head1 MAGIC + +Please use LExporter::Declare::Magic directly from now on. + +=head2 DEPRECATED USAGE OF MAGIC + + use Exporter::Declare '-magic'; + +This adds LDevel::Declare magic to several functions. It also allows you to +easily create or use parsers on your own exports. See +LExporter::Declare::Magic for more details. + +You can also provide import arguments to LDevel::Declare::Magic + + # Arguments to -magic must be in an arrayref, not a hashref. + use Exporter::Declare -magic => [ '-default', '!export', -prefix => 'magic_' ]; + +=head1 INTERNAL API + +Exporter/Declare.pm does not have much logic to speak of. Rather +Exporter::Declare is sugar on top of class meta data stored in +LExporter::Declare::Meta objects. Arguments are parsed via +LExporter::Declare::Specs, and also turned into objects. Even exports are +blessed references to the exported item itself, and handle the injection on +their own (See LExporter::Declare::Export). + +=head1 META CLASS + +All exporters have a meta class, the only way to get the meta object is to call +the exporter_meta() method on the class/object that is an exporter. Any class +that uses Exporter::Declare gets this method, and a meta-object. + +=head1 AUTHORS + +Chad Granum L + +=head1 COPYRIGHT + +Copyright (C) 2010 Chad Granum + +Exporter-Declare is free software; Standard perl licence. + +Exporter-Declare is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the license for more details. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Exporter-Declare-0.113/lib/Exporter/Declare/Meta.pm new/Exporter-Declare-0.114/lib/Exporter/Declare/Meta.pm --- old/Exporter-Declare-0.113/lib/Exporter/Declare/Meta.pm 2013-06-07 05:35:24.000000000 +0200 +++ new/Exporter-Declare-0.114/lib/Exporter/Declare/Meta.pm 2015-06-23 23:01:46.000000000 +0200 @@ -52,7 +52,12 @@ $newmerge->{$item} = $value; } $self->default_hash_merge( $data, $metric, $action, $newmerge ); - } + }, + list => sub { + my $self = shift; + my ($data) = @_; + return keys %$data; + }, ); hash_metric options => ( @@ -67,6 +72,11 @@ $self->default_hash_add( $data, $metric, $action, $item, 1 ); }, + list => sub { + my $self = shift; + my ($data) = @_; + return keys %$data; + }, ); hash_metric arguments => ( @@ -88,7 +98,12 @@ delete $newmerge->{suffix}; delete $newmerge->{prefix}; $self->default_hash_merge( $data, $metric, $action, $newmerge ); - } + }, + list => sub { + my $self = shift; + my ($data) = @_; + return keys %$data; + }, ); lists_metric export_tags => ( @@ -122,7 +137,12 @@ } $self->default_list_merge( $data, $metric, $action, $newmerge ); - } + }, + list => sub { + my $self = shift; + my ($data) = @_; + return keys %$data; + }, ); sub new { @@ -219,7 +239,7 @@ =head1 NAME -Exporter::Declare::Meta - The mata object which stoes meta-data for all +Exporter::Declare::Meta - The meta object which stores meta-data for all exporters. =head1 DESCRIPTION @@ -267,32 +287,38 @@ Add @items to the specified tag. Tag will be created if it does not already exist. $name should be the tag name B<WITHOUT> -/: prefix. +=item @list = $meta->export_tags_get( $name ) + +Get the list of items associated with the specified tag. $name should be the +tag name B<WITHOUT> -/: prefix. + +=item @list = $meta->export_tags_list() + +Get a list of all export tags. + =item $bool = $meta->is_tag( $name ) Check if a tag with the given name exists. $name should be the tag name B<WITHOUT> -/: prefix. -=item @list = $meta->get_tag( $name ) - -Get the list of items associated with the specified tag. $name should be the -tag name B<WITHOUT> -/: prefix. - -=item $meta->add_options( @names ) +=item $meta->options_add( $name ) Add import options by name. These will be boolean options that take no arguments. -=item $meta->add_arguments( @names ) +=item my @list = $meta->options_list() + +=item $meta->arguments_add( $name ) Add import options that slurp in the next argument as a value. =item $bool = $meta->is_option( $name ) -Check if the specifed name is an option. +Check if the specified name is an option. =item $bool = $meta->is_argument( $name ) -Check if the specifed name is an option that takes an argument. +Check if the specified name is an option that takes an argument. =item $meta->add_parser( $name, sub { ... }) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Exporter-Declare-0.113/lib/Exporter/Declare/Specs.pm new/Exporter-Declare-0.114/lib/Exporter/Declare/Specs.pm --- old/Exporter-Declare-0.113/lib/Exporter/Declare/Specs.pm 2013-06-07 05:35:24.000000000 +0200 +++ new/Exporter-Declare-0.114/lib/Exporter/Declare/Specs.pm 2015-06-23 23:01:46.000000000 +0200 @@ -216,7 +216,7 @@ =head1 DESCRIPTION -Import arguments cna get complicated. All arguments are assumed to be exports +Import arguments can get complicated. All arguments are assumed to be exports unless they have a - or : prefix. The prefix may denote a tag, a boolean option, or an option that takes the next argument as a value. In addition almost all these can be negated with the ! prefix. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Exporter-Declare-0.113/lib/Exporter/Declare.pm new/Exporter-Declare-0.114/lib/Exporter/Declare.pm --- old/Exporter-Declare-0.113/lib/Exporter/Declare.pm 2013-06-07 05:35:24.000000000 +0200 +++ new/Exporter-Declare-0.114/lib/Exporter/Declare.pm 2015-06-23 23:01:46.000000000 +0200 @@ -12,7 +12,7 @@ BEGIN { Meta->new(__PACKAGE__) } -our $VERSION = '0.113'; +our $VERSION = '0.114'; our @CARP_NOT = qw/ Exporter::Declare Exporter::Declare::Specs @@ -332,7 +332,7 @@ # You can create a function to mangle the arguments before they are # parsed into a Exporter::Declare::Spec object. sub alter_import_args { - my ($class, $args) = @_; + my ($class, $importer, $args) = @_; # fiddle with args before importing routines are called @$args = grep { !/^skip_/ } @$args @@ -394,7 +394,7 @@ option. Exports without a sigil are assumed to be code exports, variable exports must be listed with their sigil. -Items prefixed with the C symbol are forcfully excluded, regardless of any +Items prefixed with the C symbol are forcefully excluded, regardless of any listed item that may normally include them. Tags can also be excluded, this will effectively exclude everything in the tag. @@ -441,9 +441,9 @@ =item -alias -Every package has an alias that it can export. This is the last segmant of the +Every package has an alias that it can export. This is the last segment of the packages namespace. IE CMy::Long::Package::Name::Foo could export the C -function. These alias functionis simply return the full package name as a +function. These alias functions simply return the full package name as a string, in this case C<'My::Long::Package::Name::Foo'>. This is similar to L<aliased>. @@ -523,7 +523,7 @@ The example above will work fine, all the arguments will make it into the generator. The only valid reason for this to work is that you may provide arguments such as C<-prefix> to a tag that brings in generator(), while also -desiring to give arguments to generator() independantly. +desiring to give arguments to generator() independently. =head1 PRIMARY EXPORT API @@ -638,7 +638,7 @@ =head1 META CLASS All exporters have a meta class, the only way to get the meta object is to call -the exporter_meta() method on the class/object that is an exporter. Any class +the export_meta() method on the class/object that is an exporter. Any class that uses Exporter::Declare gets this method, and a meta-object. =head1 AUTHORS diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Exporter-Declare-0.113/t/Meta.t new/Exporter-Declare-0.114/t/Meta.t --- old/Exporter-Declare-0.113/t/Meta.t 2013-06-07 05:35:24.000000000 +0200 +++ new/Exporter-Declare-0.114/t/Meta.t 2015-06-23 23:01:46.000000000 +0200 @@ -28,6 +28,26 @@ is_deeply( $meta->arguments, { suffix => 1, prefix => 1 }, "Got arguments list" ); }; +tests options => sub { + my $meta = $CLASS->new('FakeOptionPackage'); + $meta->options_add($_) for qw/a b c/; + is_deeply( + [sort $meta->options_list], + [qw/a b c/], + "Got all options" + ); +}; + +tests arguments => sub { + my $meta = $CLASS->new('FakeArgumentsPackage'); + $meta->arguments_add($_) for qw/a b c/; + is_deeply( + [sort $meta->arguments_list], + [sort qw/a b c prefix suffix/], + "Got all arguments" + ); +}; + tests tags => sub { my $meta = $CLASS->new('FakeTagPackage'); is_deeply( @@ -47,6 +67,17 @@ $meta->export_tags_push( 'default', qw/a b c d/ ); is_deeply( [$meta->export_tags_get('default')], [qw/a b c d/], "updated default" ); + + is_deeply( + [sort $meta->export_tags_list], + [sort + 'a', + 'alias', + 'all', + 'default' + ], + "Got list of all tags" + ); }; tests exports => sub { @@ -116,6 +147,19 @@ throws_ok { $meta->exports_get( ':xxx' )} qr/exports_get\(\) does not accept a tag as an argument/, "Can't import whats not exported"; + + is_deeply( + [sort $meta->exports_list], + [sort + '$scalar', + '@array', + '%hash', + '&code_with_sigil', + '&FakeExportPackage', + '&code_no_sigil' + ], + "Got a list of all exports" + ); }; { ++++++ cpanspec.yml ++++++ --- #description_paragraphs: 3 #no_testing: broken upstream #sources: # - source1 # - source2 #patches: # foo.patch: -p1 # bar.patch: #preamble: |- # BuildRequires: gcc-c++ #post_prep: |- # hunspell=`pkg-config --libs hunspell | sed -e 's,-l,,; s, *,,g'` # sed -i -e "s,hunspell-X,$hunspell," t/00-prereq.t Makefile.PL #post_install: |- # sed on %{name}.files #license: SUSE-NonFree #skip_noarch: 1 #custom_build: |- #./Build build flags=%{?_smp_mflags} --myflag #custom_test: |- #startserver && make test #ignore_requires: Bizarre::Module