File Coverage

blib/lib/SQL/Load.pm

Criterion	Covered	Total	%
statement	68	71	95.7
branch	20	28	71.4
condition	1	3	33.3
subroutine	14	14	100.0
pod	3	3	100.0
total	106	119	89.0

package SQL::Load;

use strict;
use warnings;
use Carp;
use SQL::Load::Util qw/
    name_list
    remove_extension
/;
use SQL::Load::Method;

our $VERSION = '0.06';

sub new {
    my ($class, $path, $end) = @_;

    # valid if path exists
    croak "Path not defined!" unless $path;
    croak "The '$path' path does not exist!" unless -d $path;

    my $self = {
        _path => $path,
        _end  => $end,
        _data => {},
        _keys => {}
    };

    return bless $self, $class;
}

sub load {
    my ($self, $file_name, $reload) = @_;

    my $name;

    if ($file_name =~ /^([\w\-\/\.]+)\#([\w\-]+)$/) {
        $file_name = remove_extension($1);
        $name      = $2;
    } else {
        $file_name = remove_extension($file_name);
    }

    if ($file_name && $file_name =~ /^[\w\-\/]+$/) {
        # if true not get tmp
        unless ($reload) {
            # check if exist the key to get tmp
            my $key = $self->_key($file_name);

            # check if tmp exists, if true return
            if ($key) {
                return $name
                     ? $self->_get_tmp($key)->name($name)
                     : $self->_get_tmp($key);
            }
        }

        # get name list
        my $name_list = name_list($file_name);

        # get file from name list
        my $file = $self->_find_file($name_list);

        # get content
        my $content = $self->_file_content($file);

        # set tmp
        $self->_set_tmp($content, $file, $name_list);

        return $name
             ? SQL::Load::Method->new($content, $self->{_end})->name($name)
             : SQL::Load::Method->new($content, $self->{_end});
    }

    croak "the name '$file_name' is invalid!";
}

sub reload {
    my ($self, $file_name) = @_;

    return $self->load($file_name, 1);
}

sub _find_file {
    my ($self, $name_list) = @_;

    my $file;

    for my $name (@$name_list) {
        my $is_file = $self->{_path} . '/' . $name . '.sql';

        if (-e $is_file) {
            $file = $is_file;

            last;
        }

        last if $file;
    }

    return $file if $file;

    croak "The file does not exist!";
}

sub _file_content {
    my ($self, $file) = @_;

    my $content = '';

    open FH, '<', $file or croak $!;
    while () {
       $content .= $_;
    }
    close FH;

    $content =~ s/^\s+|\s+$//g;

    return $content;
}

sub _key {
    my ($self, $name) = @_;

    return $self->{_keys}->{$name} if exists $self->{_keys}->{$name};

    return;
}

sub _generate_key {
    my @characters = ('0'..'9', 'A'..'Z', 'a'..'z');
    my $x = int scalar @characters;
    my $result = join '', map $characters[rand $x], 1..16;

    return $result;
}

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

    return SQL::Load::Method->new($self->{_data}->{$key}->{content}, $self->{_end})
        if exists $self->{_data}->{$key}->{content};

    return;
}

sub _set_tmp {
    my ($self, $content, $file, $name_list) = @_;

    # generate new key
    my $key = $self->_generate_key;

    # save name => key in tmp keys
    $self->{_keys}->{$_} = $key for @$name_list;

    # save data in tmp data
    $self->{_data}->{$key}->{content}   = $content;
}

1;

__END__