File Coverage

blib/lib/Arepa/Config.pm

Criterion	Covered	Total	%
statement	60	62	96.7
branch	8	12	66.6
condition			n/a
subroutine	10	10	100.0
pod	6	6	100.0
total	84	90	93.3

package Arepa::Config;

use Carp qw(croak);
use File::Basename;
use File::Spec;
use YAML::Syck;

sub new {
    my ($class, $path, %user_opts) = @_;
    my %opts = (builder_config_dir => File::Spec->catfile(dirname($path),
                                                          'builders'),
                %user_opts);

    my $self = bless {
        config => LoadFile($path),
    }, $class;

    # Now, load the builder configuration
    opendir D, $opts{builder_config_dir} or
            croak "Can't read directory $opts{builder_config_dir}";
    my @builder_config_files = grep /\.yml$/, readdir D;
    closedir D;
    $self->{config}->{builders} = [];
    foreach my $file (@builder_config_files) {
        my $name = $file;
        $name =~ s/\.yml$//;
        my $path = File::Spec->catfile($opts{builder_config_dir}, $file);
        my $builder_conf = LoadFile($path);
        push @{$self->{config}->{builders}}, {%$builder_conf,
                                              name => $name};
    }

    return $self;
}

sub key_exists {
    my ($self, $key) = @_;
    my $exists = 0;

    # If get_key dies, the key doesn't exist
    eval {
        $self->get_key($key);
        $exists = 1;
    };

    return $exists;
}

sub get_key {
    my ($self, $key) = @_;

    my @keys = split(':', $key);
    my $value = $self->{config};
    foreach my $k (@keys) {
        if (defined $value->{$k}) {
            $value = $value->{$k};
        }
        else {
            croak "Can't find configuration key $key (no $k)";
        }
    }
    return $value;
}

sub get_builders {
    my ($self, %user_opts) = @_;
    my %opts = (%user_opts);

    my @builders = @{$self->{config}->{builders}};
    if (exists $opts{type}) {
        @builders = grep { $_->{type} eq $opts{type} }
                         @builders;
    }
    return map { $_->{name} } @builders;
}

sub get_builder_config {
    my ($self, $builder_name) = @_;

    my $builder_config = $self->{config}->{builders};
    my @matching_builders = grep { $_->{name} eq $builder_name }
                                 @$builder_config;
    scalar(@matching_builders) == 0 and
        croak "Don't know builder '$builder_name'";
    scalar(@matching_builders) >  1 and
        croak "There is more than one builder called '$builder_name'";
    return %{$matching_builders[0]};
}

sub get_builder_config_key {
    my ($self, $builder_name, $config_key) = @_;

    my %builder_config = $self->get_builder_config($builder_name);
    defined($builder_config{$config_key}) or
        croak "'$builder_name' doesn't have a configuration key $config_key";
    return $builder_config{$config_key};
}

1;

__END__