require YAML::Syck 0.70 for multi-document loading

[p5sagit/Config-Any.git] / lib / Config / Any.pm

diff --git a/lib/Config/Any.pm b/lib/Config/Any.pm
index 856d616..301e006 100644 (file)
--- a/lib/Config/Any.pm
+++ b/lib/Config/Any.pm
@@ -5,9 +5,8 @@ use warnings;
 
 use Carp;
 use Module::Pluggable::Object ();
-use English qw(-no_match_vars);
 
-our $VERSION = '0.09';
+our $VERSION = '0.09_02';
 
 =head1 NAME
 
@@ -15,7 +14,7 @@ Config::Any - Load configuration from different file formats, transparently
 
 =head1 VERSION
 
-This document describes Config::Any version 0.0.8
+This document describes Config::Any version 0.09_02
 
 =head1 SYNOPSIS
 
@@ -49,7 +48,7 @@ configuration formats.
 
 =cut
 
-=head2 load_files( )
+=head2 load_files( \%args )
 
     Config::Any->load_files( { files => \@files } );
     Config::Any->load_files( { files => \@files, filter  => \&filter } );
@@ -95,7 +94,7 @@ sub load_files {
     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 } );
@@ -130,63 +129,75 @@ sub load_stems {
     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         = map { $_ => 1 } @$files_ref;
-    my %force_plugins = map { $_ => 1 } @$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 = map { $_ => 1 } $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 ? @{ $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 ) {
+            $extension_lut{ $_ } = $plugin for $plugin->extensions;
+        }
+
+        $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 @results;
 
-            my $config;
-            eval { $config = $loader->load( $filename, $driver_args ); };
+    for my $filename ( @{ $args->{ files } } ) {
 
-            next if $EVAL_ERROR;    # if it croaked or warned, we can't use it
-            next if !$config;
-            delete $files{ $filename };
+        # don't even bother if it's not there
+        next unless -f $filename;
 
-            # post-process config with a filter callback, if we got one
-            $filter_cb->( $config ) if defined $filter_cb;
+        my @try_plugins = @plugins;
 
-            push @$final_configs, { $filename => $config };
+        if ( $use_ext_lut ) {
+            $filename =~ m{\.($extension_re)\z};
+            next unless $1;
+            @try_plugins = $extension_lut{ $1 };
+        }
+
+        for my $loader ( @try_plugins ) {
+            next unless $loader->is_supported;
+            my @configs
+                = eval { $loader->load( $filename, $loader_args{ $loader } ); };
+
+            # fatal error if we used extension matching
+            croak "Error parsing file: $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;
         }
     }
-    $final_configs;
+
+    return \@results;
 }
 
 =head2 finder( )
@@ -237,7 +248,7 @@ sub extensions {
 
 =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.