use Carp;
use Module::Pluggable::Object ();
-use English qw(-no_match_vars);
-our $VERSION = '0.09';
+our $VERSION = '0.24';
=head1 NAME
Config::Any - Load configuration from different file formats, transparently
-=head1 VERSION
-
-This document describes Config::Any version 0.0.8
-
=head1 SYNOPSIS
use Config::Any;
my $cfg = Config::Any->load_files({files => \@filepaths, ... });
for (@$cfg) {
- my ($filename, $config) = each %$_;
+ my ($filename, $config) = %$_;
$class->config($config);
warn "loaded config from file: $filename";
}
=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, flatten_to_hash => 1 } );
C<load_files()> attempts to load configuration from the list of files passed in
the C<files> parameter, if the file exists.
containing YAML data will not be offered to the YAML plugin, whereas C<myapp.yml>
or C<myapp.yaml> would be.
+When the C<flatten_to_hash> 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<load_files()> also supports a 'force_plugins' parameter, whose value should be an
arrayref of plugin names like C<Config::Any::INI>. Its intended use is to allow the use
of a non-standard file extension while forcing it to be offered to a particular parser.
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<load_stems()> attempts to load configuration from a list of files which it generates
by combining the filename stems list passed in the C<stems> parameter with the
sub load_stems {
my ( $class, $args ) = @_;
- return unless defined $args;
- unless ( exists $args->{ stems } ) {
- warn "no stems specified";
+
+ unless ( $args && exists $args->{ stems } ) {
+ warn "No stems specified!";
return;
}
- my %load_args
- = map { $_ => defined $args->{ $_ } ? $args->{ $_ } : undef }
- qw(filter use_ext force_plugins driver_args);
-
- $load_args{ files } = $class->_stems_to_files( $args->{ stems } );
- return $class->_load( \%load_args );
-}
-
-sub _stems_to_files {
- my ( $class, $stems ) = @_;
- return unless defined $stems;
-
+ my $stems = delete $args->{ stems };
my @files;
for my $s ( @$stems ) {
for my $ext ( $class->extensions ) {
push @files, "$s.$ext";
}
}
- return \@files;
-}
-sub _maphash { # syntactic sugar
- map { $_ => 1 } @_;
-}
+ $args->{ files } = \@files;
+ return $class->_load( $args );
+}
-# 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;
-
- my ( $loader_class ) = $loader =~ /::([^:]+)$/;
- my $driver_args = $args->{ driver_args }{ $loader_class } || {};
-
- FILE:
- for my $filename ( keys %files ) {
- next unless -f $filename;
-
- # 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;
+ 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;
+ }
+
+ # figure out what plugins we're using
+ my @plugins = $force
+ ? map { eval "require $_;"; $_; } @{ $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 );
+ }
+
+ # 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 } || {};
+ }
- my $config;
- eval { $config = $loader->load( $filename, $driver_args ); };
+ my @results;
- next if $EVAL_ERROR; # if it croaked or warned, we can't use it
- next if !$config;
- delete $files{ $filename };
+ for my $filename ( @{ $args->{ files } } ) {
- # post-process config with a filter callback, if we got one
- $filter_cb->( $config ) if defined $filter_cb;
+ # don't even bother if it's not there
+ next unless -f $filename;
- push @$final_configs, { $filename => $config };
+ 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";
+ }
+
+ @try_plugins = @{ $extension_lut{ $1 } };
+ }
+
+ # 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;
+ }
+
+ push @results,
+ { $filename => @configs == 1 ? $configs[ 0 ] : \@configs };
+ last;
+ }
+
+ 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( )
my $class = shift;
my $finder = Module::Pluggable::Object->new(
search_path => [ __PACKAGE__ ],
+ except => [ __PACKAGE__ . '::Base' ],
require => 1
);
- $finder;
+ return $finder;
}
=head2 plugins( )
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( )
sub extensions {
my $class = shift;
- my @ext = map { $_->extensions } $class->plugins;
+ my @ext
+ = map { $_->extensions } $class->plugins;
return wantarray ? @ext : \@ext;
}
=over
-=item C<no files specified> or C<no stems specified>
+=item C<No files specified!> or C<No stems specified!>
The C<load_files()> and C<load_stems()> methods will issue this warning if
called with an empty list of files/stems to load.
=head1 AUTHOR
-Joel Bernstein E<lt>rataxis@cpan.orgE<gt>
+Joel Bernstein E<lt>rataxis@cpan.orgE<gt>
=head1 CONTRIBUTORS
projects / p5sagit/Config-Any.git / blobdiff