File Coverage

blib/lib/Dancer2/ConfigReader/Config/Any.pm

Criterion	Covered	Total	%
statement	65	70	92.8
branch	12	22	54.5
condition	2	3	66.6
subroutine	13	13	100.0
pod	1	1	100.0
total	93	109	85.3

# ABSTRACT: Config reader for files
package Dancer2::ConfigReader::Config::Any;
$Dancer2::ConfigReader::Config::Any::VERSION = '2.1.0';
use Moo;

use Config::Any;
use Hash::Merge::Simple;
use Carp 'croak';
use Module::Runtime 'require_module';

use Dancer2::Core::Factory;
use Dancer2::Core;
use Dancer2::Core::Types;
use Path::Tiny qw< path >;

with 'Dancer2::Core::Role::ConfigReader';

has name => (
    is      => 'ro',
    isa     => Str,
    lazy    => 0,
    default => sub {'Config::Any'},
);

has config_files => (
    is      => 'ro',
    lazy    => 1,
    isa     => ArrayRef,
    builder => '_build_config_files',
);

has _config_files_path => (
    is       => 'ro',
    lazy     => 1,
    isa      => ArrayRef[InstanceOf['Path::Tiny']],
    builder  => '_build_config_files_path',
    init_arg => undef,
);

sub read_config {
    my ($self) = @_;

    my $config = Hash::Merge::Simple->merge(
        map {
            warn "Merging config file $_\n" if $ENV{DANCER_CONFIG_VERBOSE};
            $self->_load_config_file($_)
        } @{ $self->config_files }
    );

    return $config;
}

sub _build_config_files {
    my ($self) = @_;
    return [ map $_->stringify, @{ $self->_config_files_path } ];
}

sub _build_config_files_path {
    my ($self) = @_;

    my $location = $self->config_location;
    warn "Searching config files in location: $location\n" if $ENV{DANCER_CONFIG_VERBOSE};
    # an undef location means no config files for the caller
    return [] unless defined $location;

    my $config_location = Path::Tiny::path($location);
    my $environments_location = Path::Tiny::path( $self->environments_location );

    my $running_env = $self->environment;
    my @available_exts = Config::Any->extensions;
    my @files;

    my @exts = @available_exts;
    if (my $ext = $ENV{DANCER_CONFIG_EXT}) {
        if (grep { $ext eq $_ } @available_exts) {
            @exts = $ext;
            warn "Only looking for configs ending in '$ext'\n"
                if $ENV{DANCER_CONFIG_VERBOSE};
        } else {
            warn "DANCER_CONFIG_EXT environment variable set to '$ext' which\n" .
                 "is not recognized by Config::Any. Looking for config file\n" .
                 "using default list of extensions:\n" .
                 "\t@available_exts\n";
        }
    }

    foreach my $file ( [ $config_location, "config" ],
        [ $environments_location, $running_env ] )
    {
        foreach my $ext (@exts) {
            my $path = Path::Tiny::path( $file->[0], $file->[1] . ".$ext" );
            next unless -r $path;

            # Look for *_local.ext files
            my $local = Path::Tiny::path( $file->[0], $file->[1] . "_local.$ext" );
            push @files, $path, ( -r $local ? $local : () );
        }
    }

    warn "Found following config files: @files\n" if $ENV{DANCER_CONFIG_VERBOSE};
    return \@files;
}

sub _load_config_file {
    my ( $self, $file ) = @_;
    my $config;

    eval {
        my @files = ($file);
        my $tmpconfig =
          Config::Any->load_files( { files => \@files, use_ext => 1 } )->[0];
        ( $file, $config ) = %{$tmpconfig} if defined $tmpconfig;
    };
    if ( my $err = $@ || ( !$config ) ) {
        croak "Unable to parse the configuration file: $file: $@";
    }

    # TODO handle mergeable entries
    return $config;
}

1;

__END__