File Coverage

blib/lib/Config/ZOMG.pm

Criterion	Covered	Total	%
statement	51	54	94.4
branch	20	22	90.9
condition	5	6	83.3
subroutine	11	12	91.6
pod	4	5	80.0
total	91	99	91.9

package Config::ZOMG;
{
  $Config::ZOMG::VERSION = '1.000000';
}

# ABSTRACT: Yet Another Catalyst::Plugin::ConfigLoader-style layer over Config::Any

use Moo;
use Sub::Quote 'quote_sub';

use Config::ZOMG::Source::Loader;

use Config::Any;
use Hash::Merge::Simple;

has package => (
   is => 'ro',
);

has source => (
   is => 'rw',
   handles => [qw/ driver local_suffix no_env env_lookup path found find /],
);

has load_once => (
   is => 'ro',
   default => quote_sub q{ 1 },
);

has loaded => (
   is => 'rw',
   default => quote_sub q{ 0 },
);

has default => (
   is => 'ro',
   default => quote_sub q[ {} ],
);

has path_to => (
   is => 'ro',
   reader => '_path_to',
   builder => '_build_path_to',
   lazy => 1,
);

sub _build_path_to {
    my $self = shift;
    return $self->load->{home} if $self->load->{home};
    return $self->source->path unless $self->source->path_is_file;
    return '.';
}

has _config => (
   is => 'rw',
);

sub BUILD {
    my $self = shift;
    my $given = shift;

    my ($source, %source);
    if ($given->{file}) {

        $given->{path} = $given->{file};
        $source{path_is_file} = 1;
    }

    {
        for (qw/
            name
            path
            driver

            no_local
            local_suffix

            no_env
            env_lookup

        /) {
            $source{$_} = $given->{$_} if exists $given->{$_};
        }

        warn "Warning, 'local_suffix' will be ignored if 'file' is given, use 'path' instead" if
            exists $source{local_suffix} && exists $given->{file};

        $source = Config::ZOMG::Source::Loader->new( %source );
    }

    $self->source($source);
}

sub open {
    unless ( ref $_[0] ) {
        my $class = shift;
        return $class->new( @_ == 1 ? (file => $_[0]) : @_ )->open;
    }
    my $self = shift;
    warn "You called ->open on an instantiated object with arguments" if @_;
    my $config_hash = $self->load;
    return unless $self->found;
    return wantarray ? ($config_hash, $self) : $config_hash;
}

sub load {
    my $self = shift;

    return $self->_config if $self->loaded && $self->load_once;

    $self->_config($self->default);

    $self->_load($_) for $self->source->read;

    $self->loaded(1);

    return $self->_config;
}

sub clone {
   require Clone;
   Clone::clone($_[0]->config)
}

sub reload {
    my $self = shift;
    $self->loaded(0);
    return $self->load;
}

sub _load {
    my $self = shift;
    my $cfg = shift;

    my ($file, $hash) = %$cfg;

    $self->_config(Hash::Merge::Simple->merge($self->_config, $hash));
}

1;

__END__