File Coverage

blib/lib/Syringe.pm

Criterion	Covered	Total	%
statement	6	6	100.0
branch			n/a
condition			n/a
subroutine	2	2	100.0
pod			n/a
total	8	8	100.0

package Syringe;

use 5.6.1;

use base 'Class::Singleton';
our $VERSION = '0.01';

use Modern::Perl;
use Data::Dumper;
use Log::Log4perl qw(:easy);
use YAML::XS qw(LoadFile);
use Carp;
use Scalar::Util qw(blessed);

use Log::Log4perl qw(get_logger);

my $default_log4perl_conf = q(
    log4perl.rootLogger=DEBUG,Logfile
    log4perl.category.default=WARN,Logfile
    log4perl.appender.Logfile=Log::Log4perl::Appender::File
    log4perl.appender.Logfile.filename=test.log
    log4perl.appender.Logfile.layout=Log::Log4perl::Layout::PatternLayout
    log4perl.appender.Logfile.layout.ConversionPattern=%d %M %m %n
);

#-------------------------------------------------------------------------------


# this only gets called the first time instance() is called
sub _new_instance {
    my ($proto, %params) = @_;

    my $class = ref $proto || $proto;

    if ($params{log4perlconf}) {
        Log::Log4perl::init($params{log4perlconf});
    } else {
        Log::Log4perl::init(\$default_log4perl_conf);
    }

    $params{logger} = get_logger();

    $params{logger}->info("_new_instance called");

    my $self = bless \%params, $class;

    $params{config} = LoadFile($self->{path});

    $self->_compile;

    return $self;
}

#-------------------------------------------------------------------------------

sub logger {
    my $self = shift;
    return $self->{logger};
}

#-------------------------------------------------------------------------------

sub _config {
    my $self = shift;
    return $self->{config};
}

#-------------------------------------------------------------------------------

sub _instantiate {
    my ($self, $config, $service) = @_;

    $self->logger->info("Start instantiation of $service");

    my $class = $config->{$service}->{class}->{name};

    my $dependencies = $config->{$service}->{'dependencies'};

    my %args;

    for my $dependency_name ( keys %{ $dependencies } ) {
        $self->logger->info("Parsing dependency [$dependency_name]");
        my $value;
        my $dep_service = $dependencies->{$dependency_name}->{'service'};
        my $dep_value   = $dependencies->{$dependency_name}->{'value'};
        my $is_service  = defined $dep_service ? 1 : 0;

        # look for services first
        if ($is_service) {
            $self->logger->info("[$dependency_name] is service.");

            # check to see if it was loaded into runtime yet
            if (exists $config->{$dep_service}->{'object'}) {
                # set the value to the object in memory
                $value = $config->{$dep_service}->{'object'};
            }
            else {
                # recursive call
                $self->logger->info("[$dependency_name] is not existing service.");
                $value = $self->_instantiate($config, $dep_service);
            }
        } elsif (!$is_service) {
            $self->logger->info("[$dependency_name] is a value.");
            $value = $dep_value;
        }

        $args{$dependency_name} = $value;
    }

    my $constructor = $config->{$service}->{class}->{constructor} || 'new';

    # instantiate new object

    if ($self->logger->is_debug) {
        for my $lib (@INC) {
            $self->logger->debug("\@INC contains [ $lib ]");
        }
    }

    eval "require $class";
    eval "import $class";

    my $object = $class->$constructor(%args);

    if (ref $object eq $class) {
        $self->logger->info("Succes! instantiated service [$service] class [$class]!");
    }
    else {
        $self->logger->fatal("Failed to instantiate service [$service] class [$class]!");
    }

    $config->{$service}->{object} = $object;

    return $object;
}

#-------------------------------------------------------------------------------

sub _compile {
    my $self = shift;
    my $config = $self->_config;
    for my $service ( sort keys %$config) {
        $self->logger->info("Found service named [ $service ]!");

        $self->_instantiate($config, $service);
    }
}

#-------------------------------------------------------------------------------

sub get_class {
    my ($self, $service) = @_;

    $self->logger->debug("called with arg $service");

    return $self->_config->{$service}->{class}->{name};
}

#-------------------------------------------------------------------------------

sub get_service {
    my ($self, $service) = @_;

    $self->logger->debug("called with arg $service");

    my $config = $self->_config;

    my $object = $self->_config->{$service}->{'object'};
    my $ref    = ref $object;
    my $class  = $self->get_class($service);

    $self->logger->debug("Ref of Object returned for $service is $ref");

    if (ref $object ne $class) {
        $self->logger->fatal("Object is not a $class!");
    }

    return $object;
}

#-------------------------------------------------------------------------------

sub register_service {
    my ($self, $service_identifier, $service) = @_;

    $self->logger->info("called with service identifier [$service_identifier]");


    my $class = blessed $service;

    if (!$class) {
        $self->logger->error("Failed to pass an object!");
        croak("You must pass a blessed object!");
    }

    my $config = $self->_config;

    if (exists $config->{$service_identifier}->{'object'}) {
        $self->logger->error("Service identifier [$service_identifier] already exists!");
        croak("You are trying to register a service with an existing name!");
    }

    $config->{$service_identifier}->{'class'}->{name} = $class;
    $config->{$service_identifier}->{'object'} = $service;

    return 1;
}

#-------------------------------------------------------------------------------

1;

__END__