File Coverage

blib/lib/DBIx/QuickDB.pm

Criterion	Covered	Total	%
statement	35	80	43.7
branch	4	42	9.5
condition	2	16	12.5
subroutine	9	12	75.0
pod	2	2	100.0
total	52	152	34.2

package DBIx::QuickDB;
use strict;
use warnings;

our $VERSION = '0.000040';

use Carp;
use List::Util qw/first/;
use File::Temp qw/tempdir/;
use Module::Pluggable search_path => 'DBIx::QuickDB::Driver', max_depth => 4, require => 0;

my %CACHE;

END { local $?; %CACHE = () }

sub import {
    my $class = shift;
    my ($name, @args) = @_;

    return unless defined $name;

    my $spec = @args > 1 ? {@args} : $args[0];

    my $db = $class->build_db($name, $spec);

    my $caller = caller;
    no strict 'refs';
    *{"$caller\::$name"} = sub() { $db };
}

sub build_db {
    my $class = shift;
    my $name = ref($_[0]) ? undef : shift(@_);
    my $spec = shift(@_) || {};

    return $CACHE{$name}->{inst}
        if $name && $CACHE{$name} && !$spec->{nocache};

    unless ($spec->{dir}) {
        $spec->{dir}       = tempdir('DB-QUICK-XXXXXXXX', CLEANUP => 0, $ENV{QDB_TMPDIR} ? (DIR => $ENV{QDB_TMPDIR}) : (TMPDIR => 1));
        $spec->{cleanup}   = 1 unless defined $spec->{cleanup};
        $spec->{bootstrap} = 1 unless defined $spec->{bootstrap};
    }

    $spec->{autostart} = 1 unless defined $spec->{autostart};
    $spec->{autostop} = $spec->{autostart} unless defined $spec->{autostop};

    my $driver;
    my $drivers = $spec->{driver} ? [$spec->{driver}] : delete $spec->{drivers} || [$class->plugins];
    my %nope;
    for my $d (@$drivers) {
        my ($v, $fqn, $why) = $class->check_driver($d, $spec);
        if ($v) {
            $driver = $fqn;
            last;
        }
        $nope{$d} = $why;
    }

    unless ($driver) {
        my @err = "== Could not find a viable driver from the following ==";
        for my $d (keys %nope) {
            push @err => "\n=== $d ===", $nope{$d};
        }

        confess join "\n" => @err, "", "====================", "", "Aborting";
    }

    my $inst = $driver->new(%$spec);

    $CACHE{$name} = {spec => $spec, inst => $inst} if $name && !$spec->{nocache};

    $inst->bootstrap if $spec->{bootstrap};
    $inst->start     if $spec->{autostart};

    if (my $sql = $spec->{load_sql}) {
        $sql = $sql->{$driver->name} if ref($sql) eq 'HASH';
        $sql = [$sql] unless ref($sql) eq 'ARRAY';

        for (my $i = 0; $i < @$sql; $i += 2) {
            my ($db, $file) = @{$sql}[$i, $i + 1];
            $inst->load_sql($db => $file);
        }
    }

    return $inst;
}

sub check_driver {
    my $class = shift;
    my ($d, $spec) = @_;

    $d = "DBIx::QuickDB::Driver::$d" unless $d =~ s/^\+// || $d =~ m/^DBIx::QuickDB::Driver::/;

    my $f = $d;
    $f =~ s{::}{/}g;
    $f .= ".pm";

    my ($v, $why);
    if (eval { require $f }) {
        ($v, $why) = $d->viable($spec);
    }
    else {
        ($v, $why) = (0, "Could not load $d: $@");
    }

    return ($v, $d, $why);
}

1;

__END__