File Coverage

blib/lib/Class/DBI/Plugin/Factory.pm

Criterion	Covered	Total	%
statement	15	49	30.6
branch	0	14	0.0
condition	0	5	0.0
subroutine	5	9	55.5
pod			n/a
total	20	77	25.9

package Class::DBI::Plugin::Factory;
use strict;
use vars qw/$VERSION/;

$VERSION = '0.03';

use Class::Inspector;
use UNIVERSAL::require;

sub import {
    my $class = shift;
    my $pkg = caller(0);

    unless( $pkg->isa('Class::DBI') ){
        $class->_croak(qq/This plugin is for CDBI application./);
    }
    $pkg->mk_classdata($_) for qw/type_column _factory_types/;

    no strict 'refs';
    *{$pkg."::set_factory"} = sub {
        my($caller, %args) = @_;

        if ( $args{type_column} ) {
            $caller->type_column( $args{type_column} );
        }

        $caller->_croak(qq/Type column isn't defined./)
            unless $caller->type_column;

        $caller->_factory_types( $args{types} || {} );
        $class->_require_modules($caller);

        $caller->add_trigger( select => sub {
            my $self = shift;
            my $type = $self->type_column;
            unless( $self->can($type) ) {
                $self->_croak(qq/Couldn't call method "$type"./);
            }
            my $subclass = $self->_factory_types->{$self->$type}
                || $self->_factory_types->{'-Base'};
            unless( Class::Inspector->loaded($subclass) ) {
                $self->_croak(qq/Unknown class "$subclass"./);
            }
            bless $self, $subclass;
        } );
    }
}

sub _require_modules {
    my($class, $pkg) = @_;
    while( my($type, $module) = each %{ $pkg->_factory_types } ) {
        $module = join "::", $pkg, $module;
        unless( Class::Inspector->installed($module) ) {
            $class->_croak(qq/"$module" isn't installed./);
        }
        $module->require;
        $class->_croak(qq/Couldn't require "$module", "$@"./) if($@);
        $pkg->_factory_types->{$type} = $module;
    }
}

sub _croak {
    my($self, $msg) = @_;
    require Carp; Carp::croak($msg);
}

1;
__END__