Catalyst-Plugin-ConfigLoader-0.34/0000755000175000017500000000000012323512637016332 5ustar ilmariilmariCatalyst-Plugin-ConfigLoader-0.34/lib/0000755000175000017500000000000012323512637017100 5ustar ilmariilmariCatalyst-Plugin-ConfigLoader-0.34/lib/Catalyst/0000755000175000017500000000000012323512637020664 5ustar ilmariilmariCatalyst-Plugin-ConfigLoader-0.34/lib/Catalyst/Plugin/0000755000175000017500000000000012323512637022122 5ustar ilmariilmariCatalyst-Plugin-ConfigLoader-0.34/lib/Catalyst/Plugin/ConfigLoader/0000755000175000017500000000000012323512637024456 5ustar ilmariilmariCatalyst-Plugin-ConfigLoader-0.34/lib/Catalyst/Plugin/ConfigLoader/Manual.pod0000644000175000017500000001153012323503520026366 0ustar ilmariilmari =head1 NAME Catalyst::Plugin::ConfigLoader::Manual - Guide to using the ConfigLoader plugin =head1 BASIC USAGE package MyApp; use Catalyst qw( ConfigLoader ... ); =head1 ENVIRONMENT VARIABLES =over 4 =item * C - specific config file to load for "MyApp" =item * C - global suffix for extra config files =item * C - suffix specifically for "MyApp" =back =head1 CONFIG FORMATS =head2 Config::General =head3 Extensions =over 4 =item * cnf =item * conf =back =head3 Example Config name = TestApp foo bar qux xyzzy =head2 INI =head3 Extensions =over 4 =item * ini =back =head3 Example Config name=TestApp [Controller::Foo] foo=bar [Model::Baz] qux=xyzzy =head2 JSON =head3 Extensions =over 4 =item * jsn =item * json =back =head3 Example Config { "name": "TestApp", "Controller::Foo": { "foo": "bar" }, "Model::Baz": { "qux": "xyzzy" } } =head2 Perl =head3 Extensions =over 4 =item * pl =item * perl =back =head3 Example Config { name => 'TestApp', 'Controller::Foo' => { foo => 'bar' }, 'Model::Baz' => { qux => 'xyzzy' } } =head2 XML =head3 Extensions =over 4 =item * xml =back =head3 Example Config MyApp::CMS /var/www/docs/myapp-cms/uploads dbi:mysql:cmsdb user password __path_to(root,templates)__ UTF-8 1 2 2 Note that the name attribute for the C tag should be the relative namespace of the Catalyst model, not the absolute one. That is for C the C attribute should be C. =head2 YAML =head3 Extensions =over 4 =item * yml =item * yaml =back =head3 Example Config --- name: TestApp Controller::Foo: foo: bar Model::Baz: qux: xyzzy =head1 COOKBOOK =head2 Configuring a Catalyst::Model::DBIC::Schema model from a YAML config Model::MyModel: schema_class: MyApp::MySchema connect_info: - dbi:SQLite:myapp.db - '' - '' - AutoCommit: 1 =head2 Converting your existing config to Config::General format As of L 1.07, a newly created application will use L for configuration. If you wish to convert your existing config, run the following one-liner (replacing MyApp with your app's name): perl -Ilib -MMyApp -MConfig::General -e 'Config::General->new->save_file("myapp.conf", MyApp->config);' =head2 Using UTF-8 strings in a Config::General file If you have UTF-8 strings in your L-based config file, you should add the following config information to MyApp.pm: __PACKAGE__->config( 'Plugin::ConfigLoader' => { driver => { 'General' => { -UTF8 => 1 }, } } ); =head2 Using a local configuration file When ConfigLoader reads configurations, it starts by reading the configuration file for C with one of the supported extensions as listed L. For example, A L config file is C. If a configuration file called C exists with one of the supported file extensions, it will also be read, and values from that file will override values from the main config file. A L local configuration file would be called C. The C suffix can be changed. See L for the details of how. This is useful because it allows different people or environments to have different configuration files. A project with three developers, I, I, and I as well as a production environment can have a C, a C, a C, and a C. Each developer, and the web server, would set the environment variable to load their proper configuration file. All of the configurations can be stored properly in source control. If there is no C (where .ext is a supported extension), and the individual configuration files contain something required to start the application, such as the Model's data source definition, the applicaton won't start unless the environment variable is set properly. =cut Catalyst-Plugin-ConfigLoader-0.34/lib/Catalyst/Plugin/ConfigLoader.pm0000644000175000017500000002345512323503746025026 0ustar ilmariilmaripackage Catalyst::Plugin::ConfigLoader; use strict; use warnings; use Config::Any; use MRO::Compat; use Data::Visitor::Callback; use Catalyst::Utils (); our $VERSION = '0.34'; =head1 NAME Catalyst::Plugin::ConfigLoader - Load config files of various types =head1 SYNOPSIS package MyApp; # ConfigLoader should be first in your list so # other plugins can get the config information use Catalyst qw( ConfigLoader ... ); # by default myapp.* will be loaded # you can specify a file if you'd like __PACKAGE__->config( 'Plugin::ConfigLoader' => { file => 'config.yaml' } ); In the file, assuming it's in YAML format: foo: bar Accessible through the context object, or the class itself $c->config->{foo} # bar MyApp->config->{foo} # bar =head1 DESCRIPTION This module will attempt to load find and load a configuration file of various types. Currently it supports YAML, JSON, XML, INI and Perl formats. Special configuration for a particular driver format can be stored in Cconfig-E{ 'Plugin::ConfigLoader' }-E{ driver }>. For example, to pass arguments to L, use the following: __PACKAGE__->config( 'Plugin::ConfigLoader' => { driver => { 'General' => { -LowerCaseNames => 1 } } } ); See L's C parameter for more information. To support the distinction between development and production environments, this module will also attemp to load a local config (e.g. myapp_local.yaml) which will override any duplicate settings. See L for details on how this is configured. =head1 METHODS =head2 setup( ) This method is automatically called by Catalyst's setup routine. It will attempt to use each plugin and, once a file has been successfully loaded, set the C section. =cut sub setup { my $c = shift; my @files = $c->find_files; my $cfg = Config::Any->load_files( { files => \@files, filter => \&_fix_syntax, use_ext => 1, driver_args => $c->config->{ 'Plugin::ConfigLoader' }->{ driver } || {}, } ); # map the array of hashrefs to a simple hash my %configs = map { %$_ } @$cfg; # split the responses into normal and local cfg my $local_suffix = $c->get_config_local_suffix; my ( @main, @locals ); for ( sort keys %configs ) { if ( m{$local_suffix\.}ms ) { push @locals, $_; } else { push @main, $_; } } # load all the normal cfgs, then the local cfgs last so they can override # normal cfgs $c->load_config( { $_ => $configs{ $_ } } ) for @main, @locals; $c->finalize_config; $c->next::method( @_ ); } =head2 load_config This method handles loading the configuration data into the Catalyst context object. It does not return a value. =cut sub load_config { my $c = shift; my $ref = shift; my ( $file, $config ) = %$ref; $c->config( $config ); $c->log->debug( qq(Loaded Config "$file") ) if $c->debug; return; } =head2 find_files This method determines the potential file paths to be used for config loading. It returns an array of paths (up to the filename less the extension) to pass to L for loading. =cut sub find_files { my $c = shift; my ( $path, $extension ) = $c->get_config_path; my $suffix = $c->get_config_local_suffix; my @extensions = @{ Config::Any->extensions }; my @files; if ( $extension ) { die "Unable to handle files with the extension '${extension}'" unless grep { $_ eq $extension } @extensions; ( my $local = $path ) =~ s{\.$extension}{_$suffix.$extension}; push @files, $path, $local; } else { @files = map { ( "$path.$_", "${path}_${suffix}.$_" ) } @extensions; } @files; } =head2 get_config_path This method determines the path, filename prefix and file extension to be used for config loading. It returns the path (up to the filename less the extension) to check and the specific extension to use (if it was specified). The order of preference is specified as: =over 4 =item * C<$ENV{ MYAPP_CONFIG }> =item * C<$ENV{ CATALYST_CONFIG }> =item * C<$c-Econfig-E{ 'Plugin::ConfigLoader' }-E{ file }> =item * C<$c-Epath_to( $application_prefix )> =back If either of the first two user-specified options are directories, the application prefix will be added on to the end of the path. =cut sub get_config_path { my $c = shift; my $appname = ref $c || $c; my $prefix = Catalyst::Utils::appprefix( $appname ); my $path = Catalyst::Utils::env_value( $appname, 'CONFIG' ) || $c->config->{ 'Plugin::ConfigLoader' }->{ file } || $c->path_to( $prefix ); ## don't look for extension if this is a dir my ( $extension ) = !-d $path ? ( $path =~ m{\.([^\/\\.]{1,4})$} ) : () ; if ( -d $path ) { $path =~ s{[\/\\]$}{}; $path .= "/$prefix"; } return ( $path, $extension ); } =head2 get_config_local_suffix Determines the suffix of files used to override the main config. By default this value is C, which will load C. The suffix can be specified in the following order of preference: =over 4 =item * C<$ENV{ MYAPP_CONFIG_LOCAL_SUFFIX }> =item * C<$ENV{ CATALYST_CONFIG_LOCAL_SUFFIX }> =item * C<$c-Econfig-E{ 'Plugin::ConfigLoader' }-E{ config_local_suffix }> =back The first one of these values found replaces the default of C in the name of the local config file to be loaded. For example, if C< $ENV{ MYAPP_CONFIG_LOCAL_SUFFIX }> is set to C, ConfigLoader will try and load C instead of C. =cut sub get_config_local_suffix { my $c = shift; my $appname = ref $c || $c; my $suffix = Catalyst::Utils::env_value( $appname, 'CONFIG_LOCAL_SUFFIX' ) || $c->config->{ 'Plugin::ConfigLoader' }->{ config_local_suffix } || 'local'; return $suffix; } sub _fix_syntax { my $config = shift; my @components = ( map +{ prefix => $_ eq 'Component' ? '' : $_ . '::', values => delete $config->{ lc $_ } || delete $config->{ $_ } }, grep { ref $config->{ lc $_ } || ref $config->{ $_ } } qw( Component Model M View V Controller C Plugin ) ); foreach my $comp ( @components ) { my $prefix = $comp->{ prefix }; foreach my $element ( keys %{ $comp->{ values } } ) { $config->{ "$prefix$element" } = $comp->{ values }->{ $element }; } } } =head2 finalize_config This method is called after the config file is loaded. It can be used to implement tuning of config values that can only be done at runtime. If you need to do this to properly configure any plugins, it's important to load ConfigLoader before them. ConfigLoader provides a default finalize_config method which walks through the loaded config hash and calls the C sub on any string. =cut sub finalize_config { my $c = shift; my $v = Data::Visitor::Callback->new( plain_value => sub { return unless defined $_; $c->config_substitutions( $_ ); } ); $v->visit( $c->config ); } =head2 config_substitutions( $value ) This method substitutes macros found with calls to a function. There are a number of default macros: =over 4 =item * C<__HOME__> - replaced with C<$c-Epath_to('')> =item * C<__ENV(foo)__> - replaced with the value of C<$ENV{foo}> =item * C<__path_to(foo/bar)__> - replaced with C<$c-Epath_to('foo/bar')> =item * C<__literal(__FOO__)__> - leaves __FOO__ alone (allows you to use C<__DATA__> as a config value, for example) =back The parameter list is split on comma (C<,>). You can override this method to do your own string munging, or you can define your own macros in Cconfig-E{ 'Plugin::ConfigLoader' }-E{ substitutions }>. Example: MyApp->config->{ 'Plugin::ConfigLoader' }->{ substitutions } = { baz => sub { my $c = shift; qux( @_ ); } } The above will respond to C<__baz(x,y)__> in config strings. =cut sub config_substitutions { my $c = shift; my $subs = $c->config->{ 'Plugin::ConfigLoader' }->{ substitutions } || {}; $subs->{ HOME } ||= sub { shift->path_to( '' ); }; $subs->{ ENV } ||= sub { my ( $c, $v ) = @_; if (! defined($ENV{$v})) { Catalyst::Exception->throw( message => "Missing environment variable: $v" ); return ""; } else { return $ENV{ $v }; } }; $subs->{ path_to } ||= sub { shift->path_to( @_ ); }; $subs->{ literal } ||= sub { return $_[ 1 ]; }; my $subsre = join( '|', keys %$subs ); for ( @_ ) { s{__($subsre)(?:\((.+?)\))?__}{ $subs->{ $1 }->( $c, $2 ? split( /,/, $2 ) : () ) }eg; } } =head1 AUTHOR Brian Cassidy Ebricas@cpan.orgE =head1 CONTRIBUTORS The following people have generously donated their time to the development of this module: =over 4 =item * Joel Bernstein Erataxis@cpan.orgE - Rewrite to use L =item * David Kamholz Edkamholz@cpan.orgE - L integration =item * Stuart Watt - Addition of ENV macro. =back Work to this module has been generously sponsored by: =over 4 =item * Portugal Telecom L - Work done by Joel Bernstein =back =head1 COPYRIGHT AND LICENSE Copyright 2006-2010 by Brian Cassidy This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself. =head1 SEE ALSO =over 4 =item * L =item * L =item * L =back =cut 1; Catalyst-Plugin-ConfigLoader-0.34/MANIFEST0000644000175000017500000000255712323512621017465 0ustar ilmariilmari.gitignore Changes inc/Module/Install.pm inc/Module/Install/Base.pm inc/Module/Install/Can.pm inc/Module/Install/Fetch.pm inc/Module/Install/Makefile.pm inc/Module/Install/Metadata.pm inc/Module/Install/Win32.pm inc/Module/Install/WriteAll.pm lib/Catalyst/Plugin/ConfigLoader.pm lib/Catalyst/Plugin/ConfigLoader/Manual.pod Makefile.PL MANIFEST This list of files META.yml README t/01-use.t t/10-live_auto.t t/20-mock_load.t t/21-mock_load_env.t t/22-suffix_env.t t/23-path_env.t t/24-mock-shortappname.t t/25-setting-config-file.t t/98-pod_coverage.t t/99-pod.t t/lib/TestApp.pm t/lib/TestApp/Controller/Config.pm t/lib/TestApp/Controller/Root.pm t/lib/TestApp/testapp.pl t/lib/TestApp1.pm t/lib/TestApp1/Controller/Config.pm t/lib/TestApp1/Controller/Root.pm t/lib/TestApp1/customconfig.pl t/lib/TestApp1/testapp1.pl t/lib/TestApp2.pm t/lib/TestApp2/Controller/Config.pm t/lib/TestApp2/Controller/Root.pm t/lib/TestApp2/customconfig.pl t/lib/TestApp2/testapp2.pl t/lib/TestApp3.pm t/lib/TestApp3/config/another_file.pl t/lib/TestApp3/config/testapp3.pl t/lib/TestApp3/Controller/Config.pm t/lib/TestApp3/Controller/Root.pm t/lib/TestApp3/testapp3.pl t/lib/TestApp4.pm t/lib/TestApp4/config.d/another_file.pl t/lib/TestApp4/config.d/testapp4.pl t/lib/TestApp4/Controller/Config.pm t/lib/TestApp4/Controller/Root.pm t/lib/TestApp4/testapp.pl t/mockapp/mockapp.pl t/mockapp/mockapp_local.pl Catalyst-Plugin-ConfigLoader-0.34/README0000644000175000017500000001256712323512616017222 0ustar ilmariilmariNAME Catalyst::Plugin::ConfigLoader - Load config files of various types SYNOPSIS package MyApp; # ConfigLoader should be first in your list so # other plugins can get the config information use Catalyst qw( ConfigLoader ... ); # by default myapp.* will be loaded # you can specify a file if you'd like __PACKAGE__->config( 'Plugin::ConfigLoader' => { file => 'config.yaml' } ); In the file, assuming it's in YAML format: foo: bar Accessible through the context object, or the class itself $c->config->{foo} # bar MyApp->config->{foo} # bar DESCRIPTION This module will attempt to load find and load a configuration file of various types. Currently it supports YAML, JSON, XML, INI and Perl formats. Special configuration for a particular driver format can be stored in "MyApp->config->{ 'Plugin::ConfigLoader' }->{ driver }". For example, to pass arguments to Config::General, use the following: __PACKAGE__->config( 'Plugin::ConfigLoader' => { driver => { 'General' => { -LowerCaseNames => 1 } } } ); See Config::Any's "driver_args" parameter for more information. To support the distinction between development and production environments, this module will also attemp to load a local config (e.g. myapp_local.yaml) which will override any duplicate settings. See get_config_local_suffix for details on how this is configured. METHODS setup( ) This method is automatically called by Catalyst's setup routine. It will attempt to use each plugin and, once a file has been successfully loaded, set the "config()" section. load_config This method handles loading the configuration data into the Catalyst context object. It does not return a value. find_files This method determines the potential file paths to be used for config loading. It returns an array of paths (up to the filename less the extension) to pass to Config::Any for loading. get_config_path This method determines the path, filename prefix and file extension to be used for config loading. It returns the path (up to the filename less the extension) to check and the specific extension to use (if it was specified). The order of preference is specified as: * $ENV{ MYAPP_CONFIG } * $ENV{ CATALYST_CONFIG } * "$c->config->{ 'Plugin::ConfigLoader' }->{ file }" * "$c->path_to( $application_prefix )" If either of the first two user-specified options are directories, the application prefix will be added on to the end of the path. get_config_local_suffix Determines the suffix of files used to override the main config. By default this value is "local", which will load "myapp_local.conf". The suffix can be specified in the following order of preference: * $ENV{ MYAPP_CONFIG_LOCAL_SUFFIX } * $ENV{ CATALYST_CONFIG_LOCAL_SUFFIX } * "$c->config->{ 'Plugin::ConfigLoader' }->{ config_local_suffix }" The first one of these values found replaces the default of "local" in the name of the local config file to be loaded. For example, if $ENV{ MYAPP_CONFIG_LOCAL_SUFFIX } is set to "testing", ConfigLoader will try and load "myapp_testing.conf" instead of "myapp_local.conf". finalize_config This method is called after the config file is loaded. It can be used to implement tuning of config values that can only be done at runtime. If you need to do this to properly configure any plugins, it's important to load ConfigLoader before them. ConfigLoader provides a default finalize_config method which walks through the loaded config hash and calls the "config_substitutions" sub on any string. config_substitutions( $value ) This method substitutes macros found with calls to a function. There are a number of default macros: * "__HOME__" - replaced with "$c->path_to('')" * "__ENV(foo)__" - replaced with the value of $ENV{foo} * "__path_to(foo/bar)__" - replaced with "$c->path_to('foo/bar')" * "__literal(__FOO__)__" - leaves __FOO__ alone (allows you to use "__DATA__" as a config value, for example) The parameter list is split on comma (","). You can override this method to do your own string munging, or you can define your own macros in "MyApp->config->{ 'Plugin::ConfigLoader' }->{ substitutions }". Example: MyApp->config->{ 'Plugin::ConfigLoader' }->{ substitutions } = { baz => sub { my $c = shift; qux( @_ ); } } The above will respond to "__baz(x,y)__" in config strings. AUTHOR Brian Cassidy CONTRIBUTORS The following people have generously donated their time to the development of this module: * Joel Bernstein - Rewrite to use Config::Any * David Kamholz - Data::Visitor integration * Stuart Watt - Addition of ENV macro. Work to this module has been generously sponsored by: * Portugal Telecom - Work done by Joel Bernstein COPYRIGHT AND LICENSE Copyright 2006-2010 by Brian Cassidy This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself. SEE ALSO * Catalyst * Catalyst::Plugin::ConfigLoader::Manual * Config::Any Catalyst-Plugin-ConfigLoader-0.34/t/0000755000175000017500000000000012323512637016575 5ustar ilmariilmariCatalyst-Plugin-ConfigLoader-0.34/t/lib/0000755000175000017500000000000012323512637017343 5ustar ilmariilmariCatalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp3.pm0000644000175000017500000000055112323503520021334 0ustar ilmariilmaripackage TestApp3; use strict; use warnings; use MRO::Compat; use Catalyst qw/ConfigLoader/; our $VERSION = '0.01'; __PACKAGE__->config( "Plugin::ConfigLoader" => { file => __PACKAGE__->path_to( "config" ) } ); __PACKAGE__->setup; sub finalize_config { my $c = shift; $c->config( foo => 'bar3' ); $c->next::method( @_ ); } 1; Catalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp1/0000755000175000017500000000000012323512637021004 5ustar ilmariilmariCatalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp1/customconfig.pl0000644000175000017500000000002512323503520024025 0ustar ilmariilmari{ bar => "baz" } Catalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp1/Controller/0000755000175000017500000000000012323512637023127 5ustar ilmariilmariCatalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp1/Controller/Root.pm0000644000175000017500000000041212323503520024374 0ustar ilmariilmaripackage TestApp1::Controller::Root; use strict; use warnings; use base 'Catalyst::Controller'; __PACKAGE__->config->{namespace} = ''; sub default :Path { my ( $self, $c ) = @_; $c->response->body( 'Page not found' ); $c->response->status(404); } 1; Catalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp1/Controller/Config.pm0000644000175000017500000000045712323503520024667 0ustar ilmariilmaripackage TestApp1::Controller::Config; use strict; use warnings; use base qw( Catalyst::Controller ); sub index : Private { my ( $self, $c ) = @_; $c->res->output( $self->{ foo } ); } sub appconfig : Global { my ( $self, $c, $var ) = @_; $c->res->body( $c->config->{ $var } ); } 1; Catalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp1/testapp1.pl0000644000175000017500000000031512323503520023070 0ustar ilmariilmari{ name => 'TestApp2', Controller::Config => { foo => 'foo' }, cache => '__HOME__/cache', multi => '__HOME__,__path_to(x)__,__HOME__,__path_to(y)__', } Catalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp4/0000755000175000017500000000000012323512637021007 5ustar ilmariilmariCatalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp4/testapp.pl0000644000175000017500000000031412323503520023011 0ustar ilmariilmari{ name => 'TestApp', Controller::Config => { foo => 'foo' }, cache => '__HOME__/cache', multi => '__HOME__,__path_to(x)__,__HOME__,__path_to(y)__', } Catalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp4/config.d/0000755000175000017500000000000012323512637022476 5ustar ilmariilmariCatalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp4/config.d/testapp4.pl0000644000175000017500000000003712323503520024566 0ustar ilmariilmari{ test4_conf3 => "a_value" } Catalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp4/config.d/another_file.pl0000644000175000017500000000005012323503520025454 0ustar ilmariilmari{ test4_conf => "this is not set" } Catalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp4/Controller/0000755000175000017500000000000012323512637023132 5ustar ilmariilmariCatalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp4/Controller/Root.pm0000644000175000017500000000041212323503520024377 0ustar ilmariilmaripackage TestApp4::Controller::Root; use strict; use warnings; use base 'Catalyst::Controller'; __PACKAGE__->config->{namespace} = ''; sub default :Path { my ( $self, $c ) = @_; $c->response->body( 'Page not found' ); $c->response->status(404); } 1; Catalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp4/Controller/Config.pm0000644000175000017500000000045612323503520024671 0ustar ilmariilmaripackage TestApp4::Controller::Config; use strict; use warnings; use base qw( Catalyst::Controller ); sub index : Private { my ( $self, $c ) = @_; $c->res->output( $self->{ foo } ); } sub appconfig : Global { my ( $self, $c, $var ) = @_; $c->res->body( $c->config->{ $var } ); } 1; Catalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp.pm0000644000175000017500000000036712323503520021256 0ustar ilmariilmaripackage TestApp; use strict; use warnings; use MRO::Compat; use Catalyst qw/ConfigLoader/; our $VERSION = '0.01'; __PACKAGE__->setup; sub finalize_config { my $c = shift; $c->config( foo => 'bar' ); $c->next::method( @_ ); } 1; Catalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp1.pm0000644000175000017500000000037112323503520021332 0ustar ilmariilmaripackage TestApp1; use strict; use warnings; use MRO::Compat; use Catalyst qw/ConfigLoader/; our $VERSION = '0.01'; __PACKAGE__->setup; sub finalize_config { my $c = shift; $c->config( foo => 'bar1' ); $c->next::method( @_ ); } 1; Catalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp2.pm0000644000175000017500000000066412323503520021340 0ustar ilmariilmaripackage TestApp2; use strict; use warnings; use MRO::Compat; use Catalyst qw/ConfigLoader/; __PACKAGE__->config( "Plugin::ConfigLoader", { file => __PACKAGE__->path_to( "customconfig.pl" ) } ); our $VERSION = '0.01'; __PACKAGE__->setup; sub finalize_config { my $c = shift; $c->config( foo => 'bar2' ); $c->next::method( @_ ); } 1; Catalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp3/0000755000175000017500000000000012323512637021006 5ustar ilmariilmariCatalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp3/testapp3.pl0000644000175000017500000000031412323503520023073 0ustar ilmariilmari{ name => 'TestApp', Controller::Config => { foo => 'foo' }, cache => '__HOME__/cache', multi => '__HOME__,__path_to(x)__,__HOME__,__path_to(y)__', } Catalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp3/Controller/0000755000175000017500000000000012323512637023131 5ustar ilmariilmariCatalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp3/Controller/Root.pm0000644000175000017500000000041212323503520024376 0ustar ilmariilmaripackage TestApp3::Controller::Root; use strict; use warnings; use base 'Catalyst::Controller'; __PACKAGE__->config->{namespace} = ''; sub default :Path { my ( $self, $c ) = @_; $c->response->body( 'Page not found' ); $c->response->status(404); } 1; Catalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp3/Controller/Config.pm0000644000175000017500000000045612323503520024670 0ustar ilmariilmaripackage TestApp3::Controller::Config; use strict; use warnings; use base qw( Catalyst::Controller ); sub index : Private { my ( $self, $c ) = @_; $c->res->output( $self->{ foo } ); } sub appconfig : Global { my ( $self, $c, $var ) = @_; $c->res->body( $c->config->{ $var } ); } 1; Catalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp3/config/0000755000175000017500000000000012323512637022253 5ustar ilmariilmariCatalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp3/config/testapp3.pl0000644000175000017500000000003712323503520024342 0ustar ilmariilmari{ test3_conf3 => "a_value" } Catalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp3/config/another_file.pl0000644000175000017500000000005012323503520025231 0ustar ilmariilmari{ test4_conf => "this is not set" } Catalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp4.pm0000644000175000017500000000055312323503520021337 0ustar ilmariilmaripackage TestApp4; use strict; use warnings; use MRO::Compat; use Catalyst qw/ConfigLoader/; our $VERSION = '0.01'; __PACKAGE__->config( "Plugin::ConfigLoader" => { file => __PACKAGE__->path_to( "config.d" ) } ); __PACKAGE__->setup; sub finalize_config { my $c = shift; $c->config( foo => 'bar4' ); $c->next::method( @_ ); } 1; Catalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp/0000755000175000017500000000000012323512637020723 5ustar ilmariilmariCatalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp/testapp.pl0000644000175000017500000000031412323503520022725 0ustar ilmariilmari{ name => 'TestApp', Controller::Config => { foo => 'foo' }, cache => '__HOME__/cache', multi => '__HOME__,__path_to(x)__,__HOME__,__path_to(y)__', } Catalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp/Controller/0000755000175000017500000000000012323512637023046 5ustar ilmariilmariCatalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp/Controller/Root.pm0000644000175000017500000000041112323503520024312 0ustar ilmariilmaripackage TestApp::Controller::Root; use strict; use warnings; use base 'Catalyst::Controller'; __PACKAGE__->config->{namespace} = ''; sub default :Path { my ( $self, $c ) = @_; $c->response->body( 'Page not found' ); $c->response->status(404); } 1; Catalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp/Controller/Config.pm0000644000175000017500000000045512323503520024604 0ustar ilmariilmaripackage TestApp::Controller::Config; use strict; use warnings; use base qw( Catalyst::Controller ); sub index : Private { my ( $self, $c ) = @_; $c->res->output( $self->{ foo } ); } sub appconfig : Global { my ( $self, $c, $var ) = @_; $c->res->body( $c->config->{ $var } ); } 1; Catalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp2/0000755000175000017500000000000012323512637021005 5ustar ilmariilmariCatalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp2/testapp2.pl0000644000175000017500000000031512323503520023072 0ustar ilmariilmari{ name => 'TestApp2', Controller::Config => { foo => 'foo' }, cache => '__HOME__/cache', multi => '__HOME__,__path_to(x)__,__HOME__,__path_to(y)__', } Catalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp2/customconfig.pl0000644000175000017500000000002612323503520024027 0ustar ilmariilmari{ bar => "baz2" } Catalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp2/Controller/0000755000175000017500000000000012323512637023130 5ustar ilmariilmariCatalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp2/Controller/Root.pm0000644000175000017500000000041212323503520024375 0ustar ilmariilmaripackage TestApp2::Controller::Root; use strict; use warnings; use base 'Catalyst::Controller'; __PACKAGE__->config->{namespace} = ''; sub default :Path { my ( $self, $c ) = @_; $c->response->body( 'Page not found' ); $c->response->status(404); } 1; Catalyst-Plugin-ConfigLoader-0.34/t/lib/TestApp2/Controller/Config.pm0000644000175000017500000000045712323503520024670 0ustar ilmariilmaripackage TestApp2::Controller::Config; use strict; use warnings; use base qw( Catalyst::Controller ); sub index : Private { my ( $self, $c ) = @_; $c->res->output( $self->{ foo } ); } sub appconfig : Global { my ( $self, $c, $var ) = @_; $c->res->body( $c->config->{ $var } ); } 1; Catalyst-Plugin-ConfigLoader-0.34/t/20-mock_load.t0000644000175000017500000000175712323503520021132 0ustar ilmariilmaripackage MockApp; use Test::More tests => 10; use Cwd; # Remove all relevant env variables to avoid accidental fail foreach my $name ( grep { m{^(CATALYST)} } keys %ENV ) { delete $ENV{ $name }; } $ENV{ CATALYST_HOME } = cwd . '/t/mockapp'; use_ok( 'Catalyst', qw( ConfigLoader ) ); __PACKAGE__->config->{ 'Plugin::ConfigLoader' }->{ substitutions } = { foo => sub { shift; join( '-', @_ ); } }; __PACKAGE__->setup; ok( __PACKAGE__->config ); is( __PACKAGE__->config->{ 'Controller::Foo' }->{ foo }, 'bar' ); is( __PACKAGE__->config->{ 'Controller::Foo' }->{ new }, 'key' ); is( __PACKAGE__->config->{ 'Model::Baz' }->{ qux }, 'xyzzy' ); is( __PACKAGE__->config->{ 'Model::Baz' }->{ another }, 'new key' ); is( __PACKAGE__->config->{ 'view' }, 'View::TT::New' ); is( __PACKAGE__->config->{ 'foo_sub' }, 'x-y' ); is( __PACKAGE__->config->{ 'literal_macro' }, '__DATA__' ); is( __PACKAGE__->config->{ 'Plugin::Zot' }->{ zoot }, 'zooot'); Catalyst-Plugin-ConfigLoader-0.34/t/01-use.t0000644000175000017500000000012612323503520017762 0ustar ilmariilmariuse Test::More tests => 1; BEGIN { use_ok( 'Catalyst::Plugin::ConfigLoader' ); } Catalyst-Plugin-ConfigLoader-0.34/t/98-pod_coverage.t0000644000175000017500000000024512323503520021645 0ustar ilmariilmariuse Test::More; eval "use Test::Pod::Coverage 1.00"; plan skip_all => "Test::Pod::Coverage 1.00 required for testing POD coverage" if $@; all_pod_coverage_ok(); Catalyst-Plugin-ConfigLoader-0.34/t/mockapp/0000755000175000017500000000000012323512637020227 5ustar ilmariilmariCatalyst-Plugin-ConfigLoader-0.34/t/mockapp/mockapp_local.pl0000644000175000017500000000023712323503520023361 0ustar ilmariilmari{ view => 'View::TT::New', 'Controller::Foo' => { new => 'key' }, Component => { 'Model::Baz' => { 'another' => 'new key' } } } Catalyst-Plugin-ConfigLoader-0.34/t/mockapp/mockapp.pl0000644000175000017500000000056512323503520022213 0ustar ilmariilmari{ name => 'TestApp', view => 'View::TT', 'Controller::Foo' => { foo => 'bar' }, 'Model::Baz' => { qux => 'xyzzy' }, foo_sub => '__foo(x,y)__', literal_macro => '__literal(__DATA__)__', environment_macro => '__ENV(CATALYST_HOME)__/mockapp.pl', Plugin => { Zot => { zoot => 'zooot' } }, } Catalyst-Plugin-ConfigLoader-0.34/t/24-mock-shortappname.t0000644000175000017500000000067712323503520022636 0ustar ilmariilmariuse strict; use warnings; use Test::More; { package QX; use strict; use warnings; use Path::Class (); use base 'Catalyst::Plugin::ConfigLoader'; sub config { {} } sub path_to { shift; Path::Class::dir('/home/foo/QX-0.9.5/' . shift); } } my $app = bless {}, 'QX'; my ($path, $extension) = $app->get_config_path; is $path, Path::Class::dir( '/home/foo/QX-0.9.5/qx' )->stringify; is $extension, undef; done_testing; Catalyst-Plugin-ConfigLoader-0.34/t/99-pod.t0000644000175000017500000000020112323503520017763 0ustar ilmariilmariuse Test::More; eval "use Test::Pod 1.00"; plan skip_all => "Test::Pod 1.00 required for testing POD" if $@; all_pod_files_ok(); Catalyst-Plugin-ConfigLoader-0.34/t/22-suffix_env.t0000644000175000017500000000070312323503520021346 0ustar ilmariilmariuse strict; use warnings; use FindBin; use lib "$FindBin::Bin/lib"; use Test::More; BEGIN { eval { require Catalyst; Catalyst->VERSION( '5.80001' ); }; plan skip_all => 'Catalyst 5.80001 required' if $@; plan tests => 3; $ENV{ TESTAPP_CONFIG_LOCAL_SUFFIX } = 'test'; use_ok 'Catalyst::Test', 'TestApp'; } ok my ( $res, $c ) = ctx_request( '/' ), 'context object'; is $c->get_config_local_suffix, 'test', 'suffix is "test"'; Catalyst-Plugin-ConfigLoader-0.34/t/23-path_env.t0000644000175000017500000000072312323503520021001 0ustar ilmariilmariuse strict; use warnings; use FindBin; use lib "$FindBin::Bin/lib"; use Test::More; BEGIN { eval { require Catalyst; Catalyst->VERSION( '5.80001' ); }; plan skip_all => 'Catalyst 5.80001 required' if $@; plan tests => 3; $ENV{ TESTAPP_CONFIG } = 'test.perl'; use_ok 'Catalyst::Test', 'TestApp'; } ok my ( $res, $c ) = ctx_request( '/' ), 'context object'; is_deeply [ $c->get_config_path ], [ qw( test.perl perl ) ], 'path is "test.perl"'; Catalyst-Plugin-ConfigLoader-0.34/t/25-setting-config-file.t0000644000175000017500000000517012323503520023035 0ustar ilmariilmariuse strict; use warnings; use FindBin; use lib "$FindBin::Bin/lib"; use Test::More; BEGIN { # Remove all relevant env variables to avoid accidental fail foreach my $name ( grep { m{^(CATALYST|MOCKAPP)} } keys %ENV ) { delete $ENV{ $name }; } eval { require Catalyst; Catalyst->VERSION( '5.80001' ); }; plan skip_all => 'Catalyst 5.80001 required' if $@; plan tests => 18; use Catalyst::Test (); } ## TestApp1: a .conf config file exists but should not be loaded { Catalyst::Test->import('TestApp1'); note( "TestApp1" ); ok my ( $res, $c ) = ctx_request( '/' ), 'context object'; isa_ok( $c, "TestApp1" ); subtest "normal config loaded" => sub { is( get( '/appconfig/foo' ), "bar1", "config var foo ok" ); ## a config var not set will give a blank web page hence "" is( get( '/appconfig/bar' ), "", "config var in custom config" ); }; is( get( '/appconfig/bar' ), "", "custom config not loaded" ); } ## TestApp2: config points to a file in addition to normal config and ## should get loaded { Catalyst::Test->import('TestApp2'); note( "TestApp2" ); ok my ( $res, $c ) = ctx_request( '/' ), 'context object'; isa_ok( $c, "TestApp2" ); subtest "normal config loaded" => sub { is( get( '/appconfig/foo' ), "bar2", "config var foo" ); is( get( '/appconfig/unspecified_variable' ), "", "unknown config var" ); }; is( get( '/appconfig/bar' ), "baz2", "custom config loaded" ); } ## TestApp3: config points to a directory { Catalyst::Test->import('TestApp3'); note( "TestApp3" ); ok my ( $res, $c ) = ctx_request( '/' ), 'context object'; isa_ok( $c, "TestApp3" ); subtest "normal config loaded" => sub { is( get( '/appconfig/foo' ), "bar3", "config var foo" ); is( get( '/appconfig/unspecified_variable' ), "", "unknown config var" ); }; is( get( '/appconfig/test3_conf3' ), "a_value", "custom config var3 set" ); is( get( '/appconfig/test3_conf4' ), "", "custom config var4 not set" ); } ## TestApp4: config points to a directory with a suffix { Catalyst::Test->import('TestApp4'); note( "TestApp4" ); ok my ( $res, $c ) = ctx_request( '/' ), 'context object'; isa_ok( $c, "TestApp4" ); subtest "normal config loaded" => sub { is( get( '/appconfig/foo' ), "bar4", "config var foo" ); is( get( '/appconfig/unspecified_variable' ), "", "unknown config var" ); }; is( get( '/appconfig/test4_conf3' ), "a_value", "custom config var3 set" ); is( get( '/appconfig/test4_conf4' ), "", "custom config var4 not set" ); } Catalyst-Plugin-ConfigLoader-0.34/t/10-live_auto.t0000644000175000017500000000152712323503520021163 0ustar ilmariilmariuse strict; use warnings; use FindBin; use lib "$FindBin::Bin/lib"; use Test::More tests => 5; use Catalyst::Test 'TestApp'; { my $response; ok( $response = request( 'http://localhost/config/' ), 'request ok' ); is( $response->content, 'foo', 'config ok' ); $response = request( 'http://localhost/appconfig/cache' ); ok( $response->content !~ /^__HOME__/, 'home dir substituted in config var' ); $response = request( 'http://localhost/appconfig/foo' ); is( $response->content, 'bar', 'app finalize_config works' ); $response = request( 'http://localhost/appconfig/multi' ); my $home = TestApp->config->{ home }; my $path = join( ',', $home, TestApp->path_to( 'x' ), $home, TestApp->path_to( 'y' ) ); is( $response->content, $path, 'vars substituted in config var, twice' ); } Catalyst-Plugin-ConfigLoader-0.34/t/21-mock_load_env.t0000644000175000017500000000212512323503520021771 0ustar ilmariilmaripackage MockApp; use Test::More tests => 10; use Cwd; # Remove all relevant env variables to avoid accidental fail foreach my $name ( grep { m{^(CATALYST|MOCKAPP)} } keys %ENV ) { delete $ENV{ $name }; } $ENV{ CATALYST_HOME } = cwd . '/t/mockapp'; $ENV{ MOCKAPP_CONFIG } = $ENV{ CATALYST_HOME } . '/mockapp.pl'; use_ok( 'Catalyst', qw( ConfigLoader ) ); __PACKAGE__->config->{ 'Plugin::ConfigLoader' }->{ substitutions } = { foo => sub { shift; join( '-', @_ ); } }; __PACKAGE__->setup; ok( __PACKAGE__->config ); is( __PACKAGE__->config->{ 'Controller::Foo' }->{ foo }, 'bar' ); is( __PACKAGE__->config->{ 'Controller::Foo' }->{ new }, 'key' ); is( __PACKAGE__->config->{ 'Model::Baz' }->{ qux }, 'xyzzy' ); is( __PACKAGE__->config->{ 'Model::Baz' }->{ another }, 'new key' ); is( __PACKAGE__->config->{ 'view' }, 'View::TT::New' ); is( __PACKAGE__->config->{ 'foo_sub' }, 'x-y' ); is( __PACKAGE__->config->{ 'literal_macro' }, '__DATA__' ); is( __PACKAGE__->config->{ 'environment_macro' }, $ENV{ CATALYST_HOME }.'/mockapp.pl' ); Catalyst-Plugin-ConfigLoader-0.34/Changes0000644000175000017500000001315112323512550017620 0ustar ilmariilmariRevision history for Perl extension Catalyst::Plugin::ConfigLoader. 0.34 Wed Apr 16 2014 - Repackage without non-standard tarball headers. 0.33 Mon Jan 13 2014 - Fix config loading so that if passed a directory including a . in the file name, then loading it as a directory works (would have previously tried to force a specific filename and failed) - More comprehensive tests 0.32 Thu Mar 14 2013 - Don't ship .git inside the tarball, whoops. 0.31 Sat Mar 09 2013 - Fix repository location in metadata. 0.30 Fri Aug 20 2010 - Fix for Windows regarding changes from 0.29 0.29 Fri Aug 20 2010 - Fix issue with 2 character app names that are kept in versioned directories (e.g. app called QX in QX-2.1.5/) - bump dep on Config::Any to use the -ForceArray Config::General option (caelum) 0.28 Wed Jun 30 2010 - Pod Fixes related to config_substitutions() (Oleg Kostyuk) - Pod fix for the "Using a local configuration file" section of the Manual (RT #48823) - Expand XML config example in the manual (teejay, Kieren Diment) 0.27 Thu Aug 13 2009 - Require Catalyst 5.8 for tests that use ctx_request() (RT #48651) 0.26 Mon Aug 10 2009 - Fix test to not need "parent" (RT #48547) - Do not localize %ENV, rather, remove potentially conflicting k-v pairs (RT #48557) 0.25 Fri Aug 07 2009 - Fix get_config_local_suffix and get_config_path when finding values from ENV vars (RT #47937) 0.24 Mon Jun 29 2009 - Add an __ENV(foo)__ macro + tests (Stuart Watt) - Document CATALYST_CONFIG_LOCAL_SUFFIX and MYAPP_LOCAL_CONFIG_SUFFIX much better (Louis Erickson) - Fix so that having CATALYST_CONFIG_LOCAL_SUFFIX set in $ENV{} doesn't cause the tests to break. 0.23 Sat Apr 18 2009 - Update Data::Visitor 0.22 Mon Jan 05 2009 - add a cookbook entry re: UTF-8 and Config::General (Octavian Rasnita) - switch from NEXT to MRO::Compat 0.21 Mon Aug 11 2008 - add a cookbook entry for converting an existing config to Config::General format - fix up pod to explain in more detail how to pass options to each driver class (Sergio Salvi) - add nice syntax for plugins to match models/views/controllers (ilmari) 0.20 Fri May 02 2008 - sort configs by filename for loading (RT #31498) - updated pod with new example - die() instead of silently skip files with extensions we can't handle [THINGS THAT MAY BREAK YOUR CODE] - deprecation notices removed, support for old keys removed. 0.19 Wed Nov 21 2007 - fixed suffix appending to explicit config paths [NOTE] - Deprecation notices scream a little louder and sleep for 3 seconds as this should be the last release for them 0.18 Sat Oct 13 2007 - fix indentation on manual entry for DBIC::Schema config (Jeremy Wall) RT #29967 [NOTE] - Deprecation notices will remain intact 0.17 Fri Aug 24 2007 - Requires Catalyst::Runtime 5.7008 for env_value() [NOTE] - Deprecation notices will hold for another release 0.16 Thu Aug 23 2007 - separated out the macro expansion code into config_substitutions() (Jason Kohles) - allow users to specify their own macros in the "substitutions" config (Johnathan Rockway) - pass special constructor arguments to Config::Any. Requires Config::Any 0.08 (Gareth Kirwan) [DEPRECATION NOTICE] - the "file" and "config_local_suffix" config keys are now to be explicitly set under the Plugin::ConfigLoader key. Support for these keys will be removed in the next release. [THINGS THAT MAY BREAK YOUR CODE] - use Catalyst::Utils::env_value() to get $ENV values. This means that MYAPP_* is of higher precedence than CATALYST_* -- this differs from the behavior of older releases. 0.15 Tue Aug 21 2007 - Allow multiple __HOME__ and __path_to()__ replaces in one string (Greg Sheard) 0.14 Tue Apr 03 2007 - switch to Module::Install - added a user manual 0.13 Fri Aug 25 2006 - loading code factored out into Config::Any [rataxis@cpan.org] sponsored by Portugal Telecom 0.12 Wed Jul 12 2006 - made the "local" suffix overrideable - fixed __path_to()__ docs 0.11 Tue Jul 11 2006 - remember, kids: 09 > 1 0.1 Tue Jul 11 2006 - remove hash merging since it is now a core behavior - added C/M/V legacy shortcuts - fixed debug output some - switched to Module::Pluggable::Object 0.09 Wed May 24 2006 - ignore non-ref model/view/controller/component keys 0.08 Tue May 23 2006 - added get_config_path() which extracts the path finding code - added the ability to specify a MYAPP_CONFIG ENV variable - more granular merging of top-level hashrefs - more comprehensive tests 0.07 Mon May 01 2006 - added Config::General support - added nicer syntax for specifying models/views/controllers where available 0.06 Wed Apr 26 2006 - remove "last;" so that _local configs will be processed 0.05 Thu Apr 18 2006 - __HOME__ now corresponds to $c->path_to( '' ) and nothing else - __path_to( 'foo/bar' )__ turns in to $c->path_to( 'foo', 'bar' ) - attemps to load ${config}_local.$ext after ${config}.$ext for an overriding effect 0.04 Wed Feb 08 2006 - add finalize_config method - make default finalize_config traverse the config and substitute things beginning __HOME__/* with real path - don't use File::Slurp, produces annoying warnings on some systems 0.03 Mon Jan 30 2006 - pod fixes 0.02 Sun Jan 29 2006 - refactoring (suggested by Christian Hansen) 0.01 Sat Jan 28 2006 - original version Catalyst-Plugin-ConfigLoader-0.34/Makefile.PL0000644000175000017500000000112612323503520020273 0ustar ilmariilmariuse inc::Module::Install 0.95; if ( -e 'MANIFEST.SKIP' ) { system( 'pod2text lib/Catalyst/Plugin/ConfigLoader.pm > README' ); } perl_version '5.008'; name 'Catalyst-Plugin-ConfigLoader'; all_from 'lib/Catalyst/Plugin/ConfigLoader.pm'; requires 'Catalyst::Runtime' => '5.7008'; # needed for env_value() requires 'Data::Visitor' => '0.24'; requires 'Config::Any' => '0.20'; requires 'MRO::Compat' => '0.09'; test_requires 'Test::More'; test_requires 'Path::Class'; resources repository => 'git://git.shadowcat.co.uk/catagits/Catalyst-Plugin-ConfigLoader.git'; WriteAll; Catalyst-Plugin-ConfigLoader-0.34/.gitignore0000644000175000017500000000020112323503520020302 0ustar ilmariilmariblib/ pm_to_blib META.yml MYMETA.json MYMETA.yml Makefile README inc/ MANIFEST MANIFEST.bak Catalyst-Plugin-ConfigLoader-* *.swp Catalyst-Plugin-ConfigLoader-0.34/inc/0000755000175000017500000000000012323512637017103 5ustar ilmariilmariCatalyst-Plugin-ConfigLoader-0.34/inc/Module/0000755000175000017500000000000012323512637020330 5ustar ilmariilmariCatalyst-Plugin-ConfigLoader-0.34/inc/Module/Install/0000755000175000017500000000000012323512637021736 5ustar ilmariilmariCatalyst-Plugin-ConfigLoader-0.34/inc/Module/Install/Fetch.pm0000644000175000017500000000462712323512616023333 0ustar ilmariilmari#line 1 package Module::Install::Fetch; use strict; use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '1.06'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } sub get_file { my ($self, %args) = @_; my ($scheme, $host, $path, $file) = $args{url} =~ m|^(\w+)://([^/]+)(.+)/(.+)| or return; if ( $scheme eq 'http' and ! eval { require LWP::Simple; 1 } ) { $args{url} = $args{ftp_url} or (warn("LWP support unavailable!\n"), return); ($scheme, $host, $path, $file) = $args{url} =~ m|^(\w+)://([^/]+)(.+)/(.+)| or return; } $|++; print "Fetching '$file' from $host... "; unless (eval { require Socket; Socket::inet_aton($host) }) { warn "'$host' resolve failed!\n"; return; } return unless $scheme eq 'ftp' or $scheme eq 'http'; require Cwd; my $dir = Cwd::getcwd(); chdir $args{local_dir} or return if exists $args{local_dir}; if (eval { require LWP::Simple; 1 }) { LWP::Simple::mirror($args{url}, $file); } elsif (eval { require Net::FTP; 1 }) { eval { # use Net::FTP to get past firewall my $ftp = Net::FTP->new($host, Passive => 1, Timeout => 600); $ftp->login("anonymous", 'anonymous@example.com'); $ftp->cwd($path); $ftp->binary; $ftp->get($file) or (warn("$!\n"), return); $ftp->quit; } } elsif (my $ftp = $self->can_run('ftp')) { eval { # no Net::FTP, fallback to ftp.exe require FileHandle; my $fh = FileHandle->new; local $SIG{CHLD} = 'IGNORE'; unless ($fh->open("|$ftp -n")) { warn "Couldn't open ftp: $!\n"; chdir $dir; return; } my @dialog = split(/\n/, <<"END_FTP"); open $host user anonymous anonymous\@example.com cd $path binary get $file $file quit END_FTP foreach (@dialog) { $fh->print("$_\n") } $fh->close; } } else { warn "No working 'ftp' program available!\n"; chdir $dir; return; } unless (-f $file) { warn "Fetching failed: $@\n"; chdir $dir; return; } return if exists $args{size} and -s $file != $args{size}; system($args{run}) if exists $args{run}; unlink($file) if $args{remove}; print(((!exists $args{check_for} or -e $args{check_for}) ? "done!" : "failed! ($!)"), "\n"); chdir $dir; return !$?; } 1; Catalyst-Plugin-ConfigLoader-0.34/inc/Module/Install/Can.pm0000644000175000017500000000615712323512616023003 0ustar ilmariilmari#line 1 package Module::Install::Can; use strict; use Config (); use ExtUtils::MakeMaker (); use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '1.06'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } # check if we can load some module ### Upgrade this to not have to load the module if possible sub can_use { my ($self, $mod, $ver) = @_; $mod =~ s{::|\\}{/}g; $mod .= '.pm' unless $mod =~ /\.pm$/i; my $pkg = $mod; $pkg =~ s{/}{::}g; $pkg =~ s{\.pm$}{}i; local $@; eval { require $mod; $pkg->VERSION($ver || 0); 1 }; } # Check if we can run some command sub can_run { my ($self, $cmd) = @_; my $_cmd = $cmd; return $_cmd if (-x $_cmd or $_cmd = MM->maybe_command($_cmd)); for my $dir ((split /$Config::Config{path_sep}/, $ENV{PATH}), '.') { next if $dir eq ''; require File::Spec; my $abs = File::Spec->catfile($dir, $cmd); return $abs if (-x $abs or $abs = MM->maybe_command($abs)); } return; } # Can our C compiler environment build XS files sub can_xs { my $self = shift; # Ensure we have the CBuilder module $self->configure_requires( 'ExtUtils::CBuilder' => 0.27 ); # Do we have the configure_requires checker? local $@; eval "require ExtUtils::CBuilder;"; if ( $@ ) { # They don't obey configure_requires, so it is # someone old and delicate. Try to avoid hurting # them by falling back to an older simpler test. return $self->can_cc(); } # Do we have a working C compiler my $builder = ExtUtils::CBuilder->new( quiet => 1, ); unless ( $builder->have_compiler ) { # No working C compiler return 0; } # Write a C file representative of what XS becomes require File::Temp; my ( $FH, $tmpfile ) = File::Temp::tempfile( "compilexs-XXXXX", SUFFIX => '.c', ); binmode $FH; print $FH <<'END_C'; #include "EXTERN.h" #include "perl.h" #include "XSUB.h" int main(int argc, char **argv) { return 0; } int boot_sanexs() { return 1; } END_C close $FH; # Can the C compiler access the same headers XS does my @libs = (); my $object = undef; eval { local $^W = 0; $object = $builder->compile( source => $tmpfile, ); @libs = $builder->link( objects => $object, module_name => 'sanexs', ); }; my $result = $@ ? 0 : 1; # Clean up all the build files foreach ( $tmpfile, $object, @libs ) { next unless defined $_; 1 while unlink; } return $result; } # Can we locate a (the) C compiler sub can_cc { my $self = shift; my @chunks = split(/ /, $Config::Config{cc}) or return; # $Config{cc} may contain args; try to find out the program part while (@chunks) { return $self->can_run("@chunks") || (pop(@chunks), next); } return; } # Fix Cygwin bug on maybe_command(); if ( $^O eq 'cygwin' ) { require ExtUtils::MM_Cygwin; require ExtUtils::MM_Win32; if ( ! defined(&ExtUtils::MM_Cygwin::maybe_command) ) { *ExtUtils::MM_Cygwin::maybe_command = sub { my ($self, $file) = @_; if ($file =~ m{^/cygdrive/}i and ExtUtils::MM_Win32->can('maybe_command')) { ExtUtils::MM_Win32->maybe_command($file); } else { ExtUtils::MM_Unix->maybe_command($file); } } } } 1; __END__ #line 236 Catalyst-Plugin-ConfigLoader-0.34/inc/Module/Install/Metadata.pm0000644000175000017500000004327712323512616024026 0ustar ilmariilmari#line 1 package Module::Install::Metadata; use strict 'vars'; use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '1.06'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } my @boolean_keys = qw{ sign }; my @scalar_keys = qw{ name module_name abstract version distribution_type tests installdirs }; my @tuple_keys = qw{ configure_requires build_requires requires recommends bundles resources }; my @resource_keys = qw{ homepage bugtracker repository }; my @array_keys = qw{ keywords author }; *authors = \&author; sub Meta { shift } sub Meta_BooleanKeys { @boolean_keys } sub Meta_ScalarKeys { @scalar_keys } sub Meta_TupleKeys { @tuple_keys } sub Meta_ResourceKeys { @resource_keys } sub Meta_ArrayKeys { @array_keys } foreach my $key ( @boolean_keys ) { *$key = sub { my $self = shift; if ( defined wantarray and not @_ ) { return $self->{values}->{$key}; } $self->{values}->{$key} = ( @_ ? $_[0] : 1 ); return $self; }; } foreach my $key ( @scalar_keys ) { *$key = sub { my $self = shift; return $self->{values}->{$key} if defined wantarray and !@_; $self->{values}->{$key} = shift; return $self; }; } foreach my $key ( @array_keys ) { *$key = sub { my $self = shift; return $self->{values}->{$key} if defined wantarray and !@_; $self->{values}->{$key} ||= []; push @{$self->{values}->{$key}}, @_; return $self; }; } foreach my $key ( @resource_keys ) { *$key = sub { my $self = shift; unless ( @_ ) { return () unless $self->{values}->{resources}; return map { $_->[1] } grep { $_->[0] eq $key } @{ $self->{values}->{resources} }; } return $self->{values}->{resources}->{$key} unless @_; my $uri = shift or die( "Did not provide a value to $key()" ); $self->resources( $key => $uri ); return 1; }; } foreach my $key ( grep { $_ ne "resources" } @tuple_keys) { *$key = sub { my $self = shift; return $self->{values}->{$key} unless @_; my @added; while ( @_ ) { my $module = shift or last; my $version = shift || 0; push @added, [ $module, $version ]; } push @{ $self->{values}->{$key} }, @added; return map {@$_} @added; }; } # Resource handling my %lc_resource = map { $_ => 1 } qw{ homepage license bugtracker repository }; sub resources { my $self = shift; while ( @_ ) { my $name = shift or last; my $value = shift or next; if ( $name eq lc $name and ! $lc_resource{$name} ) { die("Unsupported reserved lowercase resource '$name'"); } $self->{values}->{resources} ||= []; push @{ $self->{values}->{resources} }, [ $name, $value ]; } $self->{values}->{resources}; } # Aliases for build_requires that will have alternative # meanings in some future version of META.yml. sub test_requires { shift->build_requires(@_) } sub install_requires { shift->build_requires(@_) } # Aliases for installdirs options sub install_as_core { $_[0]->installdirs('perl') } sub install_as_cpan { $_[0]->installdirs('site') } sub install_as_site { $_[0]->installdirs('site') } sub install_as_vendor { $_[0]->installdirs('vendor') } sub dynamic_config { my $self = shift; my $value = @_ ? shift : 1; if ( $self->{values}->{dynamic_config} ) { # Once dynamic we never change to static, for safety return 0; } $self->{values}->{dynamic_config} = $value ? 1 : 0; return 1; } # Convenience command sub static_config { shift->dynamic_config(0); } sub perl_version { my $self = shift; return $self->{values}->{perl_version} unless @_; my $version = shift or die( "Did not provide a value to perl_version()" ); # Normalize the version $version = $self->_perl_version($version); # We don't support the really old versions unless ( $version >= 5.005 ) { die "Module::Install only supports 5.005 or newer (use ExtUtils::MakeMaker)\n"; } $self->{values}->{perl_version} = $version; } sub all_from { my ( $self, $file ) = @_; unless ( defined($file) ) { my $name = $self->name or die( "all_from called with no args without setting name() first" ); $file = join('/', 'lib', split(/-/, $name)) . '.pm'; $file =~ s{.*/}{} unless -e $file; unless ( -e $file ) { die("all_from cannot find $file from $name"); } } unless ( -f $file ) { die("The path '$file' does not exist, or is not a file"); } $self->{values}{all_from} = $file; # Some methods pull from POD instead of code. # If there is a matching .pod, use that instead my $pod = $file; $pod =~ s/\.pm$/.pod/i; $pod = $file unless -e $pod; # Pull the different values $self->name_from($file) unless $self->name; $self->version_from($file) unless $self->version; $self->perl_version_from($file) unless $self->perl_version; $self->author_from($pod) unless @{$self->author || []}; $self->license_from($pod) unless $self->license; $self->abstract_from($pod) unless $self->abstract; return 1; } sub provides { my $self = shift; my $provides = ( $self->{values}->{provides} ||= {} ); %$provides = (%$provides, @_) if @_; return $provides; } sub auto_provides { my $self = shift; return $self unless $self->is_admin; unless (-e 'MANIFEST') { warn "Cannot deduce auto_provides without a MANIFEST, skipping\n"; return $self; } # Avoid spurious warnings as we are not checking manifest here. local $SIG{__WARN__} = sub {1}; require ExtUtils::Manifest; local *ExtUtils::Manifest::manicheck = sub { return }; require Module::Build; my $build = Module::Build->new( dist_name => $self->name, dist_version => $self->version, license => $self->license, ); $self->provides( %{ $build->find_dist_packages || {} } ); } sub feature { my $self = shift; my $name = shift; my $features = ( $self->{values}->{features} ||= [] ); my $mods; if ( @_ == 1 and ref( $_[0] ) ) { # The user used ->feature like ->features by passing in the second # argument as a reference. Accomodate for that. $mods = $_[0]; } else { $mods = \@_; } my $count = 0; push @$features, ( $name => [ map { ref($_) ? ( ref($_) eq 'HASH' ) ? %$_ : @$_ : $_ } @$mods ] ); return @$features; } sub features { my $self = shift; while ( my ( $name, $mods ) = splice( @_, 0, 2 ) ) { $self->feature( $name, @$mods ); } return $self->{values}->{features} ? @{ $self->{values}->{features} } : (); } sub no_index { my $self = shift; my $type = shift; push @{ $self->{values}->{no_index}->{$type} }, @_ if $type; return $self->{values}->{no_index}; } sub read { my $self = shift; $self->include_deps( 'YAML::Tiny', 0 ); require YAML::Tiny; my $data = YAML::Tiny::LoadFile('META.yml'); # Call methods explicitly in case user has already set some values. while ( my ( $key, $value ) = each %$data ) { next unless $self->can($key); if ( ref $value eq 'HASH' ) { while ( my ( $module, $version ) = each %$value ) { $self->can($key)->($self, $module => $version ); } } else { $self->can($key)->($self, $value); } } return $self; } sub write { my $self = shift; return $self unless $self->is_admin; $self->admin->write_meta; return $self; } sub version_from { require ExtUtils::MM_Unix; my ( $self, $file ) = @_; $self->version( ExtUtils::MM_Unix->parse_version($file) ); # for version integrity check $self->makemaker_args( VERSION_FROM => $file ); } sub abstract_from { require ExtUtils::MM_Unix; my ( $self, $file ) = @_; $self->abstract( bless( { DISTNAME => $self->name }, 'ExtUtils::MM_Unix' )->parse_abstract($file) ); } # Add both distribution and module name sub name_from { my ($self, $file) = @_; if ( Module::Install::_read($file) =~ m/ ^ \s* package \s* ([\w:]+) \s* ; /ixms ) { my ($name, $module_name) = ($1, $1); $name =~ s{::}{-}g; $self->name($name); unless ( $self->module_name ) { $self->module_name($module_name); } } else { die("Cannot determine name from $file\n"); } } sub _extract_perl_version { if ( $_[0] =~ m/ ^\s* (?:use|require) \s* v? ([\d_\.]+) \s* ; /ixms ) { my $perl_version = $1; $perl_version =~ s{_}{}g; return $perl_version; } else { return; } } sub perl_version_from { my $self = shift; my $perl_version=_extract_perl_version(Module::Install::_read($_[0])); if ($perl_version) { $self->perl_version($perl_version); } else { warn "Cannot determine perl version info from $_[0]\n"; return; } } sub author_from { my $self = shift; my $content = Module::Install::_read($_[0]); if ($content =~ m/ =head \d \s+ (?:authors?)\b \s* ([^\n]*) | =head \d \s+ (?:licen[cs]e|licensing|copyright|legal)\b \s* .*? copyright .*? \d\d\d[\d.]+ \s* (?:\bby\b)? \s* ([^\n]*) /ixms) { my $author = $1 || $2; # XXX: ugly but should work anyway... if (eval "require Pod::Escapes; 1") { # Pod::Escapes has a mapping table. # It's in core of perl >= 5.9.3, and should be installed # as one of the Pod::Simple's prereqs, which is a prereq # of Pod::Text 3.x (see also below). $author =~ s{ E<( (\d+) | ([A-Za-z]+) )> } { defined $2 ? chr($2) : defined $Pod::Escapes::Name2character_number{$1} ? chr($Pod::Escapes::Name2character_number{$1}) : do { warn "Unknown escape: E<$1>"; "E<$1>"; }; }gex; } elsif (eval "require Pod::Text; 1" && $Pod::Text::VERSION < 3) { # Pod::Text < 3.0 has yet another mapping table, # though the table name of 2.x and 1.x are different. # (1.x is in core of Perl < 5.6, 2.x is in core of # Perl < 5.9.3) my $mapping = ($Pod::Text::VERSION < 2) ? \%Pod::Text::HTML_Escapes : \%Pod::Text::ESCAPES; $author =~ s{ E<( (\d+) | ([A-Za-z]+) )> } { defined $2 ? chr($2) : defined $mapping->{$1} ? $mapping->{$1} : do { warn "Unknown escape: E<$1>"; "E<$1>"; }; }gex; } else { $author =~ s{E}{<}g; $author =~ s{E}{>}g; } $self->author($author); } else { warn "Cannot determine author info from $_[0]\n"; } } #Stolen from M::B my %license_urls = ( perl => 'http://dev.perl.org/licenses/', apache => 'http://apache.org/licenses/LICENSE-2.0', apache_1_1 => 'http://apache.org/licenses/LICENSE-1.1', artistic => 'http://opensource.org/licenses/artistic-license.php', artistic_2 => 'http://opensource.org/licenses/artistic-license-2.0.php', lgpl => 'http://opensource.org/licenses/lgpl-license.php', lgpl2 => 'http://opensource.org/licenses/lgpl-2.1.php', lgpl3 => 'http://opensource.org/licenses/lgpl-3.0.html', bsd => 'http://opensource.org/licenses/bsd-license.php', gpl => 'http://opensource.org/licenses/gpl-license.php', gpl2 => 'http://opensource.org/licenses/gpl-2.0.php', gpl3 => 'http://opensource.org/licenses/gpl-3.0.html', mit => 'http://opensource.org/licenses/mit-license.php', mozilla => 'http://opensource.org/licenses/mozilla1.1.php', open_source => undef, unrestricted => undef, restrictive => undef, unknown => undef, ); sub license { my $self = shift; return $self->{values}->{license} unless @_; my $license = shift or die( 'Did not provide a value to license()' ); $license = __extract_license($license) || lc $license; $self->{values}->{license} = $license; # Automatically fill in license URLs if ( $license_urls{$license} ) { $self->resources( license => $license_urls{$license} ); } return 1; } sub _extract_license { my $pod = shift; my $matched; return __extract_license( ($matched) = $pod =~ m/ (=head \d \s+ L(?i:ICEN[CS]E|ICENSING)\b.*?) (=head \d.*|=cut.*|)\z /xms ) || __extract_license( ($matched) = $pod =~ m/ (=head \d \s+ (?:C(?i:OPYRIGHTS?)|L(?i:EGAL))\b.*?) (=head \d.*|=cut.*|)\z /xms ); } sub __extract_license { my $license_text = shift or return; my @phrases = ( '(?:under )?the same (?:terms|license) as (?:perl|the perl (?:\d )?programming language)' => 'perl', 1, '(?:under )?the terms of (?:perl|the perl programming language) itself' => 'perl', 1, 'Artistic and GPL' => 'perl', 1, 'GNU general public license' => 'gpl', 1, 'GNU public license' => 'gpl', 1, 'GNU lesser general public license' => 'lgpl', 1, 'GNU lesser public license' => 'lgpl', 1, 'GNU library general public license' => 'lgpl', 1, 'GNU library public license' => 'lgpl', 1, 'GNU Free Documentation license' => 'unrestricted', 1, 'GNU Affero General Public License' => 'open_source', 1, '(?:Free)?BSD license' => 'bsd', 1, 'Artistic license 2\.0' => 'artistic_2', 1, 'Artistic license' => 'artistic', 1, 'Apache (?:Software )?license' => 'apache', 1, 'GPL' => 'gpl', 1, 'LGPL' => 'lgpl', 1, 'BSD' => 'bsd', 1, 'Artistic' => 'artistic', 1, 'MIT' => 'mit', 1, 'Mozilla Public License' => 'mozilla', 1, 'Q Public License' => 'open_source', 1, 'OpenSSL License' => 'unrestricted', 1, 'SSLeay License' => 'unrestricted', 1, 'zlib License' => 'open_source', 1, 'proprietary' => 'proprietary', 0, ); while ( my ($pattern, $license, $osi) = splice(@phrases, 0, 3) ) { $pattern =~ s#\s+#\\s+#gs; if ( $license_text =~ /\b$pattern\b/i ) { return $license; } } return ''; } sub license_from { my $self = shift; if (my $license=_extract_license(Module::Install::_read($_[0]))) { $self->license($license); } else { warn "Cannot determine license info from $_[0]\n"; return 'unknown'; } } sub _extract_bugtracker { my @links = $_[0] =~ m#L<( https?\Q://rt.cpan.org/\E[^>]+| https?\Q://github.com/\E[\w_]+/[\w_]+/issues| https?\Q://code.google.com/p/\E[\w_\-]+/issues/list )>#gx; my %links; @links{@links}=(); @links=keys %links; return @links; } sub bugtracker_from { my $self = shift; my $content = Module::Install::_read($_[0]); my @links = _extract_bugtracker($content); unless ( @links ) { warn "Cannot determine bugtracker info from $_[0]\n"; return 0; } if ( @links > 1 ) { warn "Found more than one bugtracker link in $_[0]\n"; return 0; } # Set the bugtracker bugtracker( $links[0] ); return 1; } sub requires_from { my $self = shift; my $content = Module::Install::_readperl($_[0]); my @requires = $content =~ m/^use\s+([^\W\d]\w*(?:::\w+)*)\s+(v?[\d\.]+)/mg; while ( @requires ) { my $module = shift @requires; my $version = shift @requires; $self->requires( $module => $version ); } } sub test_requires_from { my $self = shift; my $content = Module::Install::_readperl($_[0]); my @requires = $content =~ m/^use\s+([^\W\d]\w*(?:::\w+)*)\s+([\d\.]+)/mg; while ( @requires ) { my $module = shift @requires; my $version = shift @requires; $self->test_requires( $module => $version ); } } # Convert triple-part versions (eg, 5.6.1 or 5.8.9) to # numbers (eg, 5.006001 or 5.008009). # Also, convert double-part versions (eg, 5.8) sub _perl_version { my $v = $_[-1]; $v =~ s/^([1-9])\.([1-9]\d?\d?)$/sprintf("%d.%03d",$1,$2)/e; $v =~ s/^([1-9])\.([1-9]\d?\d?)\.(0|[1-9]\d?\d?)$/sprintf("%d.%03d%03d",$1,$2,$3 || 0)/e; $v =~ s/(\.\d\d\d)000$/$1/; $v =~ s/_.+$//; if ( ref($v) ) { # Numify $v = $v + 0; } return $v; } sub add_metadata { my $self = shift; my %hash = @_; for my $key (keys %hash) { warn "add_metadata: $key is not prefixed with 'x_'.\n" . "Use appopriate function to add non-private metadata.\n" unless $key =~ /^x_/; $self->{values}->{$key} = $hash{$key}; } } ###################################################################### # MYMETA Support sub WriteMyMeta { die "WriteMyMeta has been deprecated"; } sub write_mymeta_yaml { my $self = shift; # We need YAML::Tiny to write the MYMETA.yml file unless ( eval { require YAML::Tiny; 1; } ) { return 1; } # Generate the data my $meta = $self->_write_mymeta_data or return 1; # Save as the MYMETA.yml file print "Writing MYMETA.yml\n"; YAML::Tiny::DumpFile('MYMETA.yml', $meta); } sub write_mymeta_json { my $self = shift; # We need JSON to write the MYMETA.json file unless ( eval { require JSON; 1; } ) { return 1; } # Generate the data my $meta = $self->_write_mymeta_data or return 1; # Save as the MYMETA.yml file print "Writing MYMETA.json\n"; Module::Install::_write( 'MYMETA.json', JSON->new->pretty(1)->canonical->encode($meta), ); } sub _write_mymeta_data { my $self = shift; # If there's no existing META.yml there is nothing we can do return undef unless -f 'META.yml'; # We need Parse::CPAN::Meta to load the file unless ( eval { require Parse::CPAN::Meta; 1; } ) { return undef; } # Merge the perl version into the dependencies my $val = $self->Meta->{values}; my $perl = delete $val->{perl_version}; if ( $perl ) { $val->{requires} ||= []; my $requires = $val->{requires}; # Canonize to three-dot version after Perl 5.6 if ( $perl >= 5.006 ) { $perl =~ s{^(\d+)\.(\d\d\d)(\d*)}{join('.', $1, int($2||0), int($3||0))}e } unshift @$requires, [ perl => $perl ]; } # Load the advisory META.yml file my @yaml = Parse::CPAN::Meta::LoadFile('META.yml'); my $meta = $yaml[0]; # Overwrite the non-configure dependency hashs delete $meta->{requires}; delete $meta->{build_requires}; delete $meta->{recommends}; if ( exists $val->{requires} ) { $meta->{requires} = { map { @$_ } @{ $val->{requires} } }; } if ( exists $val->{build_requires} ) { $meta->{build_requires} = { map { @$_ } @{ $val->{build_requires} } }; } return $meta; } 1; Catalyst-Plugin-ConfigLoader-0.34/inc/Module/Install/WriteAll.pm0000644000175000017500000000237612323512616024024 0ustar ilmariilmari#line 1 package Module::Install::WriteAll; use strict; use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '1.06'; @ISA = qw{Module::Install::Base}; $ISCORE = 1; } sub WriteAll { my $self = shift; my %args = ( meta => 1, sign => 0, inline => 0, check_nmake => 1, @_, ); $self->sign(1) if $args{sign}; $self->admin->WriteAll(%args) if $self->is_admin; $self->check_nmake if $args{check_nmake}; unless ( $self->makemaker_args->{PL_FILES} ) { # XXX: This still may be a bit over-defensive... unless ($self->makemaker(6.25)) { $self->makemaker_args( PL_FILES => {} ) if -f 'Build.PL'; } } # Until ExtUtils::MakeMaker support MYMETA.yml, make sure # we clean it up properly ourself. $self->realclean_files('MYMETA.yml'); if ( $args{inline} ) { $self->Inline->write; } else { $self->Makefile->write; } # The Makefile write process adds a couple of dependencies, # so write the META.yml files after the Makefile. if ( $args{meta} ) { $self->Meta->write; } # Experimental support for MYMETA if ( $ENV{X_MYMETA} ) { if ( $ENV{X_MYMETA} eq 'JSON' ) { $self->Meta->write_mymeta_json; } else { $self->Meta->write_mymeta_yaml; } } return 1; } 1; Catalyst-Plugin-ConfigLoader-0.34/inc/Module/Install/Win32.pm0000644000175000017500000000340312323512616023173 0ustar ilmariilmari#line 1 package Module::Install::Win32; use strict; use Module::Install::Base (); use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '1.06'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } # determine if the user needs nmake, and download it if needed sub check_nmake { my $self = shift; $self->load('can_run'); $self->load('get_file'); require Config; return unless ( $^O eq 'MSWin32' and $Config::Config{make} and $Config::Config{make} =~ /^nmake\b/i and ! $self->can_run('nmake') ); print "The required 'nmake' executable not found, fetching it...\n"; require File::Basename; my $rv = $self->get_file( url => 'http://download.microsoft.com/download/vc15/Patch/1.52/W95/EN-US/Nmake15.exe', ftp_url => 'ftp://ftp.microsoft.com/Softlib/MSLFILES/Nmake15.exe', local_dir => File::Basename::dirname($^X), size => 51928, run => 'Nmake15.exe /o > nul', check_for => 'Nmake.exe', remove => 1, ); die <<'END_MESSAGE' unless $rv; ------------------------------------------------------------------------------- Since you are using Microsoft Windows, you will need the 'nmake' utility before installation. It's available at: http://download.microsoft.com/download/vc15/Patch/1.52/W95/EN-US/Nmake15.exe or ftp://ftp.microsoft.com/Softlib/MSLFILES/Nmake15.exe Please download the file manually, save it to a directory in %PATH% (e.g. C:\WINDOWS\COMMAND\), then launch the MS-DOS command line shell, "cd" to that directory, and run "Nmake15.exe" from there; that will create the 'nmake.exe' file needed by this module. You may then resume the installation process described in README. ------------------------------------------------------------------------------- END_MESSAGE } 1; Catalyst-Plugin-ConfigLoader-0.34/inc/Module/Install/Makefile.pm0000644000175000017500000002743712323512616024023 0ustar ilmariilmari#line 1 package Module::Install::Makefile; use strict 'vars'; use ExtUtils::MakeMaker (); use Module::Install::Base (); use Fcntl qw/:flock :seek/; use vars qw{$VERSION @ISA $ISCORE}; BEGIN { $VERSION = '1.06'; @ISA = 'Module::Install::Base'; $ISCORE = 1; } sub Makefile { $_[0] } my %seen = (); sub prompt { shift; # Infinite loop protection my @c = caller(); if ( ++$seen{"$c[1]|$c[2]|$_[0]"} > 3 ) { die "Caught an potential prompt infinite loop ($c[1]|$c[2]|$_[0])"; } # In automated testing or non-interactive session, always use defaults if ( ($ENV{AUTOMATED_TESTING} or -! -t STDIN) and ! $ENV{PERL_MM_USE_DEFAULT} ) { local $ENV{PERL_MM_USE_DEFAULT} = 1; goto &ExtUtils::MakeMaker::prompt; } else { goto &ExtUtils::MakeMaker::prompt; } } # Store a cleaned up version of the MakeMaker version, # since we need to behave differently in a variety of # ways based on the MM version. my $makemaker = eval $ExtUtils::MakeMaker::VERSION; # If we are passed a param, do a "newer than" comparison. # Otherwise, just return the MakeMaker version. sub makemaker { ( @_ < 2 or $makemaker >= eval($_[1]) ) ? $makemaker : 0 } # Ripped from ExtUtils::MakeMaker 6.56, and slightly modified # as we only need to know here whether the attribute is an array # or a hash or something else (which may or may not be appendable). my %makemaker_argtype = ( C => 'ARRAY', CONFIG => 'ARRAY', # CONFIGURE => 'CODE', # ignore DIR => 'ARRAY', DL_FUNCS => 'HASH', DL_VARS => 'ARRAY', EXCLUDE_EXT => 'ARRAY', EXE_FILES => 'ARRAY', FUNCLIST => 'ARRAY', H => 'ARRAY', IMPORTS => 'HASH', INCLUDE_EXT => 'ARRAY', LIBS => 'ARRAY', # ignore '' MAN1PODS => 'HASH', MAN3PODS => 'HASH', META_ADD => 'HASH', META_MERGE => 'HASH', PL_FILES => 'HASH', PM => 'HASH', PMLIBDIRS => 'ARRAY', PMLIBPARENTDIRS => 'ARRAY', PREREQ_PM => 'HASH', CONFIGURE_REQUIRES => 'HASH', SKIP => 'ARRAY', TYPEMAPS => 'ARRAY', XS => 'HASH', # VERSION => ['version',''], # ignore # _KEEP_AFTER_FLUSH => '', clean => 'HASH', depend => 'HASH', dist => 'HASH', dynamic_lib=> 'HASH', linkext => 'HASH', macro => 'HASH', postamble => 'HASH', realclean => 'HASH', test => 'HASH', tool_autosplit => 'HASH', # special cases where you can use makemaker_append CCFLAGS => 'APPENDABLE', DEFINE => 'APPENDABLE', INC => 'APPENDABLE', LDDLFLAGS => 'APPENDABLE', LDFROM => 'APPENDABLE', ); sub makemaker_args { my ($self, %new_args) = @_; my $args = ( $self->{makemaker_args} ||= {} ); foreach my $key (keys %new_args) { if ($makemaker_argtype{$key}) { if ($makemaker_argtype{$key} eq 'ARRAY') { $args->{$key} = [] unless defined $args->{$key}; unless (ref $args->{$key} eq 'ARRAY') { $args->{$key} = [$args->{$key}] } push @{$args->{$key}}, ref $new_args{$key} eq 'ARRAY' ? @{$new_args{$key}} : $new_args{$key}; } elsif ($makemaker_argtype{$key} eq 'HASH') { $args->{$key} = {} unless defined $args->{$key}; foreach my $skey (keys %{ $new_args{$key} }) { $args->{$key}{$skey} = $new_args{$key}{$skey}; } } elsif ($makemaker_argtype{$key} eq 'APPENDABLE') { $self->makemaker_append($key => $new_args{$key}); } } else { if (defined $args->{$key}) { warn qq{MakeMaker attribute "$key" is overriden; use "makemaker_append" to append values\n}; } $args->{$key} = $new_args{$key}; } } return $args; } # For mm args that take multiple space-seperated args, # append an argument to the current list. sub makemaker_append { my $self = shift; my $name = shift; my $args = $self->makemaker_args; $args->{$name} = defined $args->{$name} ? join( ' ', $args->{$name}, @_ ) : join( ' ', @_ ); } sub build_subdirs { my $self = shift; my $subdirs = $self->makemaker_args->{DIR} ||= []; for my $subdir (@_) { push @$subdirs, $subdir; } } sub clean_files { my $self = shift; my $clean = $self->makemaker_args->{clean} ||= {}; %$clean = ( %$clean, FILES => join ' ', grep { length $_ } ($clean->{FILES} || (), @_), ); } sub realclean_files { my $self = shift; my $realclean = $self->makemaker_args->{realclean} ||= {}; %$realclean = ( %$realclean, FILES => join ' ', grep { length $_ } ($realclean->{FILES} || (), @_), ); } sub libs { my $self = shift; my $libs = ref $_[0] ? shift : [ shift ]; $self->makemaker_args( LIBS => $libs ); } sub inc { my $self = shift; $self->makemaker_args( INC => shift ); } sub _wanted_t { } sub tests_recursive { my $self = shift; my $dir = shift || 't'; unless ( -d $dir ) { die "tests_recursive dir '$dir' does not exist"; } my %tests = map { $_ => 1 } split / /, ($self->tests || ''); require File::Find; File::Find::find( sub { /\.t$/ and -f $_ and $tests{"$File::Find::dir/*.t"} = 1 }, $dir ); $self->tests( join ' ', sort keys %tests ); } sub write { my $self = shift; die "&Makefile->write() takes no arguments\n" if @_; # Check the current Perl version my $perl_version = $self->perl_version; if ( $perl_version ) { eval "use $perl_version; 1" or die "ERROR: perl: Version $] is installed, " . "but we need version >= $perl_version"; } # Make sure we have a new enough MakeMaker require ExtUtils::MakeMaker; if ( $perl_version and $self->_cmp($perl_version, '5.006') >= 0 ) { # This previous attempted to inherit the version of # ExtUtils::MakeMaker in use by the module author, but this # was found to be untenable as some authors build releases # using future dev versions of EU:MM that nobody else has. # Instead, #toolchain suggests we use 6.59 which is the most # stable version on CPAN at time of writing and is, to quote # ribasushi, "not terminally fucked, > and tested enough". # TODO: We will now need to maintain this over time to push # the version up as new versions are released. $self->build_requires( 'ExtUtils::MakeMaker' => 6.59 ); $self->configure_requires( 'ExtUtils::MakeMaker' => 6.59 ); } else { # Allow legacy-compatibility with 5.005 by depending on the # most recent EU:MM that supported 5.005. $self->build_requires( 'ExtUtils::MakeMaker' => 6.36 ); $self->configure_requires( 'ExtUtils::MakeMaker' => 6.36 ); } # Generate the MakeMaker params my $args = $self->makemaker_args; $args->{DISTNAME} = $self->name; $args->{NAME} = $self->module_name || $self->name; $args->{NAME} =~ s/-/::/g; $args->{VERSION} = $self->version or die <<'EOT'; ERROR: Can't determine distribution version. Please specify it explicitly via 'version' in Makefile.PL, or set a valid $VERSION in a module, and provide its file path via 'version_from' (or 'all_from' if you prefer) in Makefile.PL. EOT if ( $self->tests ) { my @tests = split ' ', $self->tests; my %seen; $args->{test} = { TESTS => (join ' ', grep {!$seen{$_}++} @tests), }; } elsif ( $Module::Install::ExtraTests::use_extratests ) { # Module::Install::ExtraTests doesn't set $self->tests and does its own tests via harness. # So, just ignore our xt tests here. } elsif ( -d 'xt' and ($Module::Install::AUTHOR or $ENV{RELEASE_TESTING}) ) { $args->{test} = { TESTS => join( ' ', map { "$_/*.t" } grep { -d $_ } qw{ t xt } ), }; } if ( $] >= 5.005 ) { $args->{ABSTRACT} = $self->abstract; $args->{AUTHOR} = join ', ', @{$self->author || []}; } if ( $self->makemaker(6.10) ) { $args->{NO_META} = 1; #$args->{NO_MYMETA} = 1; } if ( $self->makemaker(6.17) and $self->sign ) { $args->{SIGN} = 1; } unless ( $self->is_admin ) { delete $args->{SIGN}; } if ( $self->makemaker(6.31) and $self->license ) { $args->{LICENSE} = $self->license; } my $prereq = ($args->{PREREQ_PM} ||= {}); %$prereq = ( %$prereq, map { @$_ } # flatten [module => version] map { @$_ } grep $_, ($self->requires) ); # Remove any reference to perl, PREREQ_PM doesn't support it delete $args->{PREREQ_PM}->{perl}; # Merge both kinds of requires into BUILD_REQUIRES my $build_prereq = ($args->{BUILD_REQUIRES} ||= {}); %$build_prereq = ( %$build_prereq, map { @$_ } # flatten [module => version] map { @$_ } grep $_, ($self->configure_requires, $self->build_requires) ); # Remove any reference to perl, BUILD_REQUIRES doesn't support it delete $args->{BUILD_REQUIRES}->{perl}; # Delete bundled dists from prereq_pm, add it to Makefile DIR my $subdirs = ($args->{DIR} || []); if ($self->bundles) { my %processed; foreach my $bundle (@{ $self->bundles }) { my ($mod_name, $dist_dir) = @$bundle; delete $prereq->{$mod_name}; $dist_dir = File::Basename::basename($dist_dir); # dir for building this module if (not exists $processed{$dist_dir}) { if (-d $dist_dir) { # List as sub-directory to be processed by make push @$subdirs, $dist_dir; } # Else do nothing: the module is already present on the system $processed{$dist_dir} = undef; } } } unless ( $self->makemaker('6.55_03') ) { %$prereq = (%$prereq,%$build_prereq); delete $args->{BUILD_REQUIRES}; } if ( my $perl_version = $self->perl_version ) { eval "use $perl_version; 1" or die "ERROR: perl: Version $] is installed, " . "but we need version >= $perl_version"; if ( $self->makemaker(6.48) ) { $args->{MIN_PERL_VERSION} = $perl_version; } } if ($self->installdirs) { warn qq{old INSTALLDIRS (probably set by makemaker_args) is overriden by installdirs\n} if $args->{INSTALLDIRS}; $args->{INSTALLDIRS} = $self->installdirs; } my %args = map { ( $_ => $args->{$_} ) } grep {defined($args->{$_} ) } keys %$args; my $user_preop = delete $args{dist}->{PREOP}; if ( my $preop = $self->admin->preop($user_preop) ) { foreach my $key ( keys %$preop ) { $args{dist}->{$key} = $preop->{$key}; } } my $mm = ExtUtils::MakeMaker::WriteMakefile(%args); $self->fix_up_makefile($mm->{FIRST_MAKEFILE} || 'Makefile'); } sub fix_up_makefile { my $self = shift; my $makefile_name = shift; my $top_class = ref($self->_top) || ''; my $top_version = $self->_top->VERSION || ''; my $preamble = $self->preamble ? "# Preamble by $top_class $top_version\n" . $self->preamble : ''; my $postamble = "# Postamble by $top_class $top_version\n" . ($self->postamble || ''); local *MAKEFILE; open MAKEFILE, "+< $makefile_name" or die "fix_up_makefile: Couldn't open $makefile_name: $!"; eval { flock MAKEFILE, LOCK_EX }; my $makefile = do { local $/; }; $makefile =~ s/\b(test_harness\(\$\(TEST_VERBOSE\), )/$1'inc', /; $makefile =~ s/( -I\$\(INST_ARCHLIB\))/ -Iinc$1/g; $makefile =~ s/( "-I\$\(INST_LIB\)")/ "-Iinc"$1/g; $makefile =~ s/^(FULLPERL = .*)/$1 "-Iinc"/m; $makefile =~ s/^(PERL = .*)/$1 "-Iinc"/m; # Module::Install will never be used to build the Core Perl # Sometimes PERL_LIB and PERL_ARCHLIB get written anyway, which breaks # PREFIX/PERL5LIB, and thus, install_share. Blank them if they exist $makefile =~ s/^PERL_LIB = .+/PERL_LIB =/m; #$makefile =~ s/^PERL_ARCHLIB = .+/PERL_ARCHLIB =/m; # Perl 5.005 mentions PERL_LIB explicitly, so we have to remove that as well. $makefile =~ s/(\"?)-I\$\(PERL_LIB\)\1//g; # XXX - This is currently unused; not sure if it breaks other MM-users # $makefile =~ s/^pm_to_blib\s+:\s+/pm_to_blib :: /mg; seek MAKEFILE, 0, SEEK_SET; truncate MAKEFILE, 0; print MAKEFILE "$preamble$makefile$postamble" or die $!; close MAKEFILE or die $!; 1; } sub preamble { my ($self, $text) = @_; $self->{preamble} = $text . $self->{preamble} if defined $text; $self->{preamble}; } sub postamble { my ($self, $text) = @_; $self->{postamble} ||= $self->admin->postamble; $self->{postamble} .= $text if defined $text; $self->{postamble} } 1; __END__ #line 544 Catalyst-Plugin-ConfigLoader-0.34/inc/Module/Install/Base.pm0000644000175000017500000000214712323512616023147 0ustar ilmariilmari#line 1 package Module::Install::Base; use strict 'vars'; use vars qw{$VERSION}; BEGIN { $VERSION = '1.06'; } # Suspend handler for "redefined" warnings BEGIN { my $w = $SIG{__WARN__}; $SIG{__WARN__} = sub { $w }; } #line 42 sub new { my $class = shift; unless ( defined &{"${class}::call"} ) { *{"${class}::call"} = sub { shift->_top->call(@_) }; } unless ( defined &{"${class}::load"} ) { *{"${class}::load"} = sub { shift->_top->load(@_) }; } bless { @_ }, $class; } #line 61 sub AUTOLOAD { local $@; my $func = eval { shift->_top->autoload } or return; goto &$func; } #line 75 sub _top { $_[0]->{_top}; } #line 90 sub admin { $_[0]->_top->{admin} or Module::Install::Base::FakeAdmin->new; } #line 106 sub is_admin { ! $_[0]->admin->isa('Module::Install::Base::FakeAdmin'); } sub DESTROY {} package Module::Install::Base::FakeAdmin; use vars qw{$VERSION}; BEGIN { $VERSION = $Module::Install::Base::VERSION; } my $fake; sub new { $fake ||= bless(\@_, $_[0]); } sub AUTOLOAD {} sub DESTROY {} # Restore warning handler BEGIN { $SIG{__WARN__} = $SIG{__WARN__}->(); } 1; #line 159 Catalyst-Plugin-ConfigLoader-0.34/inc/Module/Install.pm0000644000175000017500000003013512323512616022273 0ustar ilmariilmari#line 1 package Module::Install; # For any maintainers: # The load order for Module::Install is a bit magic. # It goes something like this... # # IF ( host has Module::Install installed, creating author mode ) { # 1. Makefile.PL calls "use inc::Module::Install" # 2. $INC{inc/Module/Install.pm} set to installed version of inc::Module::Install # 3. The installed version of inc::Module::Install loads # 4. inc::Module::Install calls "require Module::Install" # 5. The ./inc/ version of Module::Install loads # } ELSE { # 1. Makefile.PL calls "use inc::Module::Install" # 2. $INC{inc/Module/Install.pm} set to ./inc/ version of Module::Install # 3. The ./inc/ version of Module::Install loads # } use 5.005; use strict 'vars'; use Cwd (); use File::Find (); use File::Path (); use vars qw{$VERSION $MAIN}; BEGIN { # All Module::Install core packages now require synchronised versions. # This will be used to ensure we don't accidentally load old or # different versions of modules. # This is not enforced yet, but will be some time in the next few # releases once we can make sure it won't clash with custom # Module::Install extensions. $VERSION = '1.06'; # Storage for the pseudo-singleton $MAIN = undef; *inc::Module::Install::VERSION = *VERSION; @inc::Module::Install::ISA = __PACKAGE__; } sub import { my $class = shift; my $self = $class->new(@_); my $who = $self->_caller; #------------------------------------------------------------- # all of the following checks should be included in import(), # to allow "eval 'require Module::Install; 1' to test # installation of Module::Install. (RT #51267) #------------------------------------------------------------- # Whether or not inc::Module::Install is actually loaded, the # $INC{inc/Module/Install.pm} is what will still get set as long as # the caller loaded module this in the documented manner. # If not set, the caller may NOT have loaded the bundled version, and thus # they may not have a MI version that works with the Makefile.PL. This would # result in false errors or unexpected behaviour. And we don't want that. my $file = join( '/', 'inc', split /::/, __PACKAGE__ ) . '.pm'; unless ( $INC{$file} ) { die <<"END_DIE" } Please invoke ${\__PACKAGE__} with: use inc::${\__PACKAGE__}; not: use ${\__PACKAGE__}; END_DIE # This reportedly fixes a rare Win32 UTC file time issue, but # as this is a non-cross-platform XS module not in the core, # we shouldn't really depend on it. See RT #24194 for detail. # (Also, this module only supports Perl 5.6 and above). eval "use Win32::UTCFileTime" if $^O eq 'MSWin32' && $] >= 5.006; # If the script that is loading Module::Install is from the future, # then make will detect this and cause it to re-run over and over # again. This is bad. Rather than taking action to touch it (which # is unreliable on some platforms and requires write permissions) # for now we should catch this and refuse to run. if ( -f $0 ) { my $s = (stat($0))[9]; # If the modification time is only slightly in the future, # sleep briefly to remove the problem. my $a = $s - time; if ( $a > 0 and $a < 5 ) { sleep 5 } # Too far in the future, throw an error. my $t = time; if ( $s > $t ) { die <<"END_DIE" } Your installer $0 has a modification time in the future ($s > $t). This is known to create infinite loops in make. Please correct this, then run $0 again. END_DIE } # Build.PL was formerly supported, but no longer is due to excessive # difficulty in implementing every single feature twice. if ( $0 =~ /Build.PL$/i ) { die <<"END_DIE" } Module::Install no longer supports Build.PL. It was impossible to maintain duel backends, and has been deprecated. Please remove all Build.PL files and only use the Makefile.PL installer. END_DIE #------------------------------------------------------------- # To save some more typing in Module::Install installers, every... # use inc::Module::Install # ...also acts as an implicit use strict. $^H |= strict::bits(qw(refs subs vars)); #------------------------------------------------------------- unless ( -f $self->{file} ) { foreach my $key (keys %INC) { delete $INC{$key} if $key =~ /Module\/Install/; } local $^W; require "$self->{path}/$self->{dispatch}.pm"; File::Path::mkpath("$self->{prefix}/$self->{author}"); $self->{admin} = "$self->{name}::$self->{dispatch}"->new( _top => $self ); $self->{admin}->init; @_ = ($class, _self => $self); goto &{"$self->{name}::import"}; } local $^W; *{"${who}::AUTOLOAD"} = $self->autoload; $self->preload; # Unregister loader and worker packages so subdirs can use them again delete $INC{'inc/Module/Install.pm'}; delete $INC{'Module/Install.pm'}; # Save to the singleton $MAIN = $self; return 1; } sub autoload { my $self = shift; my $who = $self->_caller; my $cwd = Cwd::cwd(); my $sym = "${who}::AUTOLOAD"; $sym->{$cwd} = sub { my $pwd = Cwd::cwd(); if ( my $code = $sym->{$pwd} ) { # Delegate back to parent dirs goto &$code unless $cwd eq $pwd; } unless ($$sym =~ s/([^:]+)$//) { # XXX: it looks like we can't retrieve the missing function # via $$sym (usually $main::AUTOLOAD) in this case. # I'm still wondering if we should slurp Makefile.PL to # get some context or not ... my ($package, $file, $line) = caller; die <<"EOT"; Unknown function is found at $file line $line. Execution of $file aborted due to runtime errors. If you're a contributor to a project, you may need to install some Module::Install extensions from CPAN (or other repository). If you're a user of a module, please contact the author. EOT } my $method = $1; if ( uc($method) eq $method ) { # Do nothing return; } elsif ( $method =~ /^_/ and $self->can($method) ) { # Dispatch to the root M:I class return $self->$method(@_); } # Dispatch to the appropriate plugin unshift @_, ( $self, $1 ); goto &{$self->can('call')}; }; } sub preload { my $self = shift; unless ( $self->{extensions} ) { $self->load_extensions( "$self->{prefix}/$self->{path}", $self ); } my @exts = @{$self->{extensions}}; unless ( @exts ) { @exts = $self->{admin}->load_all_extensions; } my %seen; foreach my $obj ( @exts ) { while (my ($method, $glob) = each %{ref($obj) . '::'}) { next unless $obj->can($method); next if $method =~ /^_/; next if $method eq uc($method); $seen{$method}++; } } my $who = $self->_caller; foreach my $name ( sort keys %seen ) { local $^W; *{"${who}::$name"} = sub { ${"${who}::AUTOLOAD"} = "${who}::$name"; goto &{"${who}::AUTOLOAD"}; }; } } sub new { my ($class, %args) = @_; delete $INC{'FindBin.pm'}; { # to suppress the redefine warning local $SIG{__WARN__} = sub {}; require FindBin; } # ignore the prefix on extension modules built from top level. my $base_path = Cwd::abs_path($FindBin::Bin); unless ( Cwd::abs_path(Cwd::cwd()) eq $base_path ) { delete $args{prefix}; } return $args{_self} if $args{_self}; $args{dispatch} ||= 'Admin'; $args{prefix} ||= 'inc'; $args{author} ||= ($^O eq 'VMS' ? '_author' : '.author'); $args{bundle} ||= 'inc/BUNDLES'; $args{base} ||= $base_path; $class =~ s/^\Q$args{prefix}\E:://; $args{name} ||= $class; $args{version} ||= $class->VERSION; unless ( $args{path} ) { $args{path} = $args{name}; $args{path} =~ s!::!/!g; } $args{file} ||= "$args{base}/$args{prefix}/$args{path}.pm"; $args{wrote} = 0; bless( \%args, $class ); } sub call { my ($self, $method) = @_; my $obj = $self->load($method) or return; splice(@_, 0, 2, $obj); goto &{$obj->can($method)}; } sub load { my ($self, $method) = @_; $self->load_extensions( "$self->{prefix}/$self->{path}", $self ) unless $self->{extensions}; foreach my $obj (@{$self->{extensions}}) { return $obj if $obj->can($method); } my $admin = $self->{admin} or die <<"END_DIE"; The '$method' method does not exist in the '$self->{prefix}' path! Please remove the '$self->{prefix}' directory and run $0 again to load it. END_DIE my $obj = $admin->load($method, 1); push @{$self->{extensions}}, $obj; $obj; } sub load_extensions { my ($self, $path, $top) = @_; my $should_reload = 0; unless ( grep { ! ref $_ and lc $_ eq lc $self->{prefix} } @INC ) { unshift @INC, $self->{prefix}; $should_reload = 1; } foreach my $rv ( $self->find_extensions($path) ) { my ($file, $pkg) = @{$rv}; next if $self->{pathnames}{$pkg}; local $@; my $new = eval { local $^W; require $file; $pkg->can('new') }; unless ( $new ) { warn $@ if $@; next; } $self->{pathnames}{$pkg} = $should_reload ? delete $INC{$file} : $INC{$file}; push @{$self->{extensions}}, &{$new}($pkg, _top => $top ); } $self->{extensions} ||= []; } sub find_extensions { my ($self, $path) = @_; my @found; File::Find::find( sub { my $file = $File::Find::name; return unless $file =~ m!^\Q$path\E/(.+)\.pm\Z!is; my $subpath = $1; return if lc($subpath) eq lc($self->{dispatch}); $file = "$self->{path}/$subpath.pm"; my $pkg = "$self->{name}::$subpath"; $pkg =~ s!/!::!g; # If we have a mixed-case package name, assume case has been preserved # correctly. Otherwise, root through the file to locate the case-preserved # version of the package name. if ( $subpath eq lc($subpath) || $subpath eq uc($subpath) ) { my $content = Module::Install::_read($subpath . '.pm'); my $in_pod = 0; foreach ( split //, $content ) { $in_pod = 1 if /^=\w/; $in_pod = 0 if /^=cut/; next if ($in_pod || /^=cut/); # skip pod text next if /^\s*#/; # and comments if ( m/^\s*package\s+($pkg)\s*;/i ) { $pkg = $1; last; } } } push @found, [ $file, $pkg ]; }, $path ) if -d $path; @found; } ##################################################################### # Common Utility Functions sub _caller { my $depth = 0; my $call = caller($depth); while ( $call eq __PACKAGE__ ) { $depth++; $call = caller($depth); } return $call; } # Done in evals to avoid confusing Perl::MinimumVersion eval( $] >= 5.006 ? <<'END_NEW' : <<'END_OLD' ); die $@ if $@; sub _read { local *FH; open( FH, '<', $_[0] ) or die "open($_[0]): $!"; my $string = do { local $/; }; close FH or die "close($_[0]): $!"; return $string; } END_NEW sub _read { local *FH; open( FH, "< $_[0]" ) or die "open($_[0]): $!"; my $string = do { local $/; }; close FH or die "close($_[0]): $!"; return $string; } END_OLD sub _readperl { my $string = Module::Install::_read($_[0]); $string =~ s/(?:\015{1,2}\012|\015|\012)/\n/sg; $string =~ s/(\n)\n*__(?:DATA|END)__\b.*\z/$1/s; $string =~ s/\n\n=\w+.+?\n\n=cut\b.+?\n+/\n\n/sg; return $string; } sub _readpod { my $string = Module::Install::_read($_[0]); $string =~ s/(?:\015{1,2}\012|\015|\012)/\n/sg; return $string if $_[0] =~ /\.pod\z/; $string =~ s/(^|\n=cut\b.+?\n+)[^=\s].+?\n(\n=\w+|\z)/$1$2/sg; $string =~ s/\n*=pod\b[^\n]*\n+/\n\n/sg; $string =~ s/\n*=cut\b[^\n]*\n+/\n\n/sg; $string =~ s/^\n+//s; return $string; } # Done in evals to avoid confusing Perl::MinimumVersion eval( $] >= 5.006 ? <<'END_NEW' : <<'END_OLD' ); die $@ if $@; sub _write { local *FH; open( FH, '>', $_[0] ) or die "open($_[0]): $!"; foreach ( 1 .. $#_ ) { print FH $_[$_] or die "print($_[0]): $!"; } close FH or die "close($_[0]): $!"; } END_NEW sub _write { local *FH; open( FH, "> $_[0]" ) or die "open($_[0]): $!"; foreach ( 1 .. $#_ ) { print FH $_[$_] or die "print($_[0]): $!"; } close FH or die "close($_[0]): $!"; } END_OLD # _version is for processing module versions (eg, 1.03_05) not # Perl versions (eg, 5.8.1). sub _version ($) { my $s = shift || 0; my $d =()= $s =~ /(\.)/g; if ( $d >= 2 ) { # Normalise multipart versions $s =~ s/(\.)(\d{1,3})/sprintf("$1%03d",$2)/eg; } $s =~ s/^(\d+)\.?//; my $l = $1 || 0; my @v = map { $_ . '0' x (3 - length $_) } $s =~ /(\d{1,3})\D?/g; $l = $l . '.' . join '', @v if @v; return $l + 0; } sub _cmp ($$) { _version($_[1]) <=> _version($_[2]); } # Cloned from Params::Util::_CLASS sub _CLASS ($) { ( defined $_[0] and ! ref $_[0] and $_[0] =~ m/^[^\W\d]\w*(?:::\w+)*\z/s ) ? $_[0] : undef; } 1; # Copyright 2008 - 2012 Adam Kennedy. Catalyst-Plugin-ConfigLoader-0.34/META.yml0000644000175000017500000000136012323512616017600 0ustar ilmariilmari--- abstract: 'Load config files of various types' author: - 'Brian Cassidy ' build_requires: ExtUtils::MakeMaker: 6.59 Path::Class: 0 Test::More: 0 configure_requires: ExtUtils::MakeMaker: 6.59 distribution_type: module dynamic_config: 1 generated_by: 'Module::Install version 1.06' license: perl meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: 1.4 name: Catalyst-Plugin-ConfigLoader no_index: directory: - inc - t requires: Catalyst::Runtime: 5.7008 Config::Any: 0.20 Data::Visitor: 0.24 MRO::Compat: 0.09 perl: 5.8.0 resources: license: http://dev.perl.org/licenses/ repository: git://git.shadowcat.co.uk/catagits/Catalyst-Plugin-ConfigLoader.git version: 0.34