X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?p=p5sagit%2FConfig-Any.git;a=blobdiff_plain;f=lib%2FConfig%2FAny.pm;h=16dcd1b70bfab03640f711902e0895bc17af6a7f;hp=c64c12cb648574f6374a73ed80855df22990562f;hb=0ac17764e57cb8e9593dea270d876758e759ca64;hpb=4ab3432cd53b63f3979ead71525ebcf217825328 diff --git a/lib/Config/Any.pm b/lib/Config/Any.pm index c64c12c..16dcd1b 100644 --- a/lib/Config/Any.pm +++ b/lib/Config/Any.pm @@ -1,34 +1,30 @@ package Config::Any; -# $Id: $ -use warnings; + use strict; +use warnings; + use Carp; use Module::Pluggable::Object (); -use English qw(-no_match_vars); -our $VERSION = '0.06'; +our $VERSION = '0.16'; =head1 NAME Config::Any - Load configuration from different file formats, transparently -=head1 VERSION - -This document describes Config::Any version 0.0.5 - =head1 SYNOPSIS use Config::Any; - my $cfg = Config::Any->load_stems({stems => \@filepath_stems, ... }); - # or - my $cfg = Config::Any->load_files({files => \@filepaths, ... }); + my $cfg = Config::Any->load_stems({stems => \@filepath_stems, ... }); + # or + my $cfg = Config::Any->load_files({files => \@filepaths, ... }); - for (@$cfg) { - my ($filename, $config) = each %$_; - $class->config($config); - warn "loaded config from file: $filename"; - } + for (@$cfg) { + my ($filename, $config) = %$_; + $class->config($config); + warn "loaded config from file: $filename"; + } =head1 DESCRIPTION @@ -48,11 +44,12 @@ configuration formats. =cut -=head2 load_files( ) +=head2 load_files( \%args ) - Config::Any->load_files({files => \@files]}); - Config::Any->load_files({files => \@files, filter => \&filter}); - Config::Any->load_files({files => \@files, use_ext => 1}); + Config::Any->load_files( { files => \@files } ); + Config::Any->load_files( { files => \@files, filter => \&filter } ); + Config::Any->load_files( { files => \@files, use_ext => 1 } ); + Config::Any->load_files( { files => \@files, flatten_to_hash => 1 } ); C attempts to load configuration from the list of files passed in the C parameter, if the file exists. @@ -69,32 +66,40 @@ be aware that you will lose flexibility -- for example, a file called C or C would be. +When the C parameter is defined, the loader will return a hash +keyed on the file names, as opposed to the usual list of single-key hashes. + C also supports a 'force_plugins' parameter, whose value should be an arrayref of plugin names like C. Its intended use is to allow the use of a non-standard file extension while forcing it to be offered to a particular parser. It is not compatible with 'use_ext'. +You can supply a C hashref to pass special options to a particular +parser object. Example: + + Config::Any->load_files( { files => \@files, driver_args => { + General => { -LowerCaseNames => 1 } + } ) + =cut sub load_files { - my ($class, $args) = @_; - return unless defined $args; - unless (exists $args->{files}) { - warn "no files specified"; + my ( $class, $args ) = @_; + + unless ( $args && exists $args->{ files } ) { + warn "No files specified!"; return; } - my %load_args = map { $_ => defined $args->{$_} ? $args->{$_} : undef } - qw(filter use_ext force_plugins); - $load_args{files} = [ grep { -f $_ } @{$args->{files}} ]; - return $class->_load(\%load_args); + return $class->_load( $args ); } -=head2 load_stems( ) +=head2 load_stems( \%args ) - Config::Any->load_stems({stems => \@stems]}); - Config::Any->load_stems({stems => \@stems, filter => \&filter}); - Config::Any->load_stems({stems => \@stems, use_ext => 1}); + Config::Any->load_stems( { stems => \@stems } ); + Config::Any->load_stems( { stems => \@stems, filter => \&filter } ); + Config::Any->load_stems( { stems => \@stems, use_ext => 1 } ); + Config::Any->load_stems( { stems => \@stems, flatten_to_hash => 1 } ); C attempts to load configuration from a list of files which it generates by combining the filename stems list passed in the C parameter with the @@ -106,95 +111,130 @@ parameters. Please read the C documentation before using this meth =cut sub load_stems { - my ($class, $args) = @_; - return unless defined $args; - unless (exists $args->{stems}) { - warn "no stems specified"; + my ( $class, $args ) = @_; + + unless ( $args && exists $args->{ stems } ) { + warn "No stems specified!"; return; } - - my %load_args = map { $_ => defined $args->{$_} ? $args->{$_} : undef } - qw(filter use_ext force_plugins); - my $filenames = $class->_stems_to_files($args->{stems}); - $load_args{files} = [ grep { -f $_ } @{$filenames} ]; - return $class->_load(\%load_args); + my $stems = delete $args->{ stems }; + my @files; + for my $s ( @$stems ) { + for my $ext ( $class->extensions ) { + push @files, "$s.$ext"; + } + } + + $args->{ files } = \@files; + return $class->_load( $args ); } -sub _stems_to_files { - my ($class, $stems) = @_; - return unless defined $stems; +sub _load { + my ( $class, $args ) = @_; + croak "_load requires a arrayref of file paths" unless $args->{ files }; + + my $force = defined $args->{ force_plugins }; + if ( !$force and !defined $args->{ use_ext } ) { + warn + "use_ext argument was not explicitly set, as of 0.09, this is true by default"; + $args->{ use_ext } = 1; + } - my @files; - STEM: - for my $s (@$stems) { - EXT: - for my $ext ($class->extensions) { - my $file = "$s.$ext"; - next EXT unless -f $file; - push @files, $file; - last EXT; + # figure out what plugins we're using + my @plugins = $force ? @{ $args->{ force_plugins } } : $class->plugins; + + # map extensions if we have to + my ( %extension_lut, $extension_re ); + my $use_ext_lut = !$force && $args->{ use_ext }; + if ( $use_ext_lut ) { + for my $plugin ( @plugins ) { + for ( $plugin->extensions ) { + $extension_lut{ $_ } ||= []; + push @{ $extension_lut{ $_ } }, $plugin; + } } + + $extension_re = join( '|', keys %extension_lut ); } - \@files; -} -sub _maphash (@) { map { $_ => 1 } @_ } # sugar + # map args to plugins + my $base_class = __PACKAGE__; + my %loader_args; + for my $plugin ( @plugins ) { + $plugin =~ m{^$base_class\::(.+)}; + $loader_args{ $plugin } = $args->{ driver_args }->{ $1 } || {}; + } -# this is where we do the real work -# it's a private class-method because users should use the interface described -# in the POD. -sub _load { - my ($class, $args) = @_; - my ($files_ref, $filter_cb, $use_ext, $force_plugins_ref) = - @{$args}{qw(files filter use_ext force_plugins)}; - croak "_load requires a arrayref of file paths" unless defined $files_ref; - - my %files = _maphash @$files_ref; - my %force_plugins = _maphash @$force_plugins_ref; - my $enforcing = keys %force_plugins ? 1 : 0; - - my $final_configs = []; - my $originally_loaded = {}; - - # perform a separate file loop for each loader - for my $loader ( $class->plugins ) { - next if $enforcing && not defined $force_plugins{$loader}; - last unless keys %files; - my %ext = _maphash $loader->extensions; - - FILE: - for my $filename (keys %files) { - # use file extension to decide whether this loader should try this file - # use_ext => 1 hits this block - if (defined $use_ext && !$enforcing) { - my $matched_ext = 0; - EXT: - for my $e (keys %ext) { - next EXT unless $filename =~ m{ \. $e \z }xms; - next FILE unless exists $ext{$e}; - $matched_ext = 1; - } - - next FILE unless $matched_ext; + my @results; + + for my $filename ( @{ $args->{ files } } ) { + + # don't even bother if it's not there + next unless -f $filename; + + my @try_plugins = @plugins; + + if ( $use_ext_lut ) { + $filename =~ m{\.($extension_re)\z}; + + if ( !$1 ) { + $filename =~ m{\.([^.]+)\z}; + croak "There are no loaders available for .${1} files"; } - my $config; - eval { - $config = $loader->load( $filename ); - }; + @try_plugins = @{ $extension_lut{ $1 } }; + } - next if $EVAL_ERROR; # if it croaked or warned, we can't use it - next if !$config; - delete $files{$filename}; + # not using use_ext means we try all plugins anyway, so we'll + # ignore it for the "unsupported" error + my $supported = $use_ext_lut ? 0 : 1; + for my $loader ( @try_plugins ) { + next unless $loader->is_supported; + $supported = 1; + my @configs + = eval { $loader->load( $filename, $loader_args{ $loader } ); }; + + # fatal error if we used extension matching + croak "Error parsing $filename: $@" if $@ and $use_ext_lut; + next if $@ or !@configs; + + # post-process config with a filter callback + if ( $args->{ filter } ) { + $args->{ filter }->( $_ ) for @configs; + } - # post-process config with a filter callback, if we got one - $filter_cb->( $config ) if defined $filter_cb; + push @results, + { $filename => @configs == 1 ? $configs[ 0 ] : \@configs }; + last; + } - push @$final_configs, { $filename => $config }; + if ( !$supported ) { + croak + "Cannot load $filename: required support modules are not available.\nPlease install " + . join( " OR ", map { _support_error( $_ ) } @try_plugins ); } } - $final_configs; + + if ( defined $args->{ flatten_to_hash } ) { + my %flattened = map { %$_ } @results; + return \%flattened; + } + + return \@results; +} + +sub _support_error { + my $module = shift; + if ( $module->can( 'requires_all_of' ) ) { + return join( ' and ', + map { ref $_ ? join( ' ', @$_ ) : $_ } $module->requires_all_of ); + } + if ( $module->can( 'requires_any_of' ) ) { + return 'one of ' + . join( ' or ', + map { ref $_ ? join( ' ', @$_ ) : $_ } $module->requires_any_of ); + } } =head2 finder( ) @@ -207,12 +247,13 @@ more information. =cut sub finder { - my $class = shift; + my $class = shift; my $finder = Module::Pluggable::Object->new( search_path => [ __PACKAGE__ ], + except => [ __PACKAGE__ . '::Base' ], require => 1 ); - $finder; + return $finder; } =head2 plugins( ) @@ -224,7 +265,9 @@ found by L. sub plugins { my $class = shift; - return $class->finder->plugins; + + # filter out things that don't look like our plugins + return grep { $_->isa( 'Config::Any::Base' ) } $class->finder->plugins; } =head2 extensions( ) @@ -237,15 +280,16 @@ parameter to those methods. sub extensions { my $class = shift; - my @ext = map { $_->extensions } $class->plugins; - return wantarray ? @ext : [@ext]; + my @ext + = map { $_->extensions } grep { $_->is_supported } $class->plugins; + return wantarray ? @ext : \@ext; } =head1 DIAGNOSTICS =over -=item C or C +=item C or C The C and C methods will issue this warning if called with an empty list of files/stems to load. @@ -289,7 +333,7 @@ L. =head1 AUTHOR -Joel Bernstein C<< >> +Joel Bernstein Erataxis@cpan.orgE =head1 CONTRIBUTORS