File Coverage

lib/Mojolicious/Plugin/BModel.pm

Criterion	Covered	Total	%
statement	49	102	48.0
branch	9	34	26.4
condition	5	12	41.6
subroutine	14	22	63.6
pod	1	3	33.3
total	78	173	45.0

package Mojolicious::Plugin::BModel;

use 5.010;
use strict;
use warnings;
use Carp qw/ carp croak /;
use File::Find qw/ find /;
use List::Util qw/ first /;
use File::Spec;

use Mojo::Loader;
use Mojo::Base 'Mojolicious::Plugin';

our $VERSION = '0.1';

my $DEFAULT_CREATE_DIR = 1;
my $DEFAULT_MODEL_DIR  = 'Model'; # directory of poject for the Model-modules
my %MODULES    = ();
my $BASE_MODEL = 'Mojolicious::BModel::Base';

sub register {
    my ( $self, $app, $conf ) = @_;

    my $app_name  = ref $app; # name of calling Mojo app

    # namespace path to Models dir. By default it is the name of application, but it can be redefine.
    # For example, namespace can be MyPath::ToModel or any other
    my $namespace = $conf->{namespace} ? $conf->{namespace} : $app_name;
    if ( ! $self->_check_namespace( $namespace ) ) {
        croak "Wrong format of namespace $namespace. Exit";
    }

    my $namespace_path = $self->_convert_namespace_to_path( $namespace );

    # work with considering operation system
    my $path_to_model = File::Spec->catfile( $app->home->child('lib')->to_string, $namespace_path, $DEFAULT_MODEL_DIR );
    my $dir_exists    = $self->_check_model_dir( $path_to_model );
    my $to_create_dir = exists $conf->{create_dir} ? $conf->{create_dir} : $DEFAULT_CREATE_DIR;

    if ( ! ( $dir_exists && $to_create_dir ) ) {
        carp "Directory " . File::Spec->catfile( $namespace_path, $DEFAULT_MODEL_DIR ) . " does not exist";
        return 1;
    }
    elsif ( ! $dir_exists && $to_create_dir ) {
        mkdir $path_to_model or croak "Could not create directory $path_to_model : $!";
    }

    $self->load_models( $path_to_model, $namespace, $app );

    $app->helper(
        model => sub {
            my ( $self, $model_name ) = @_;
            croak "Unknown model $model_name" if ! exists $MODULES{ $model_name };
            return $MODULES{ $model_name };
        }
    );

    return 1;
}

# check a path to the 'Model' dir
sub _check_model_dir {
    my ( $self, $path_to_model ) = @_;

    return 1 if -e $path_to_model && -d $path_to_model;
    return;
}

# check for validation of namespace
sub _check_namespace {
    my ( $self, $namespace ) = @_;

    my @splitted_namespace = $self->_separate_namespace_name( $namespace );
    return if ! scalar @splitted_namespace;

    my $found_wrong_name = first { $_ !~ m/[a-zA-Z0-9]/ } @splitted_namespace;
    return if $found_wrong_name;

    return 1;
}

# convert name like 'Aaaa::Bbbbb::Cccc' to 'Aaaa/Bbbbb/Cccc' for Unix-like OS or 'Aaaa\Bbbbb\Cccc' for Windows
sub _convert_namespace_to_path {
    my ( $self, $namespace ) = @_;

    my @splitted_namespace = $self->_separate_namespace_name( $namespace );
    my $path = scalar @splitted_namespace == 1 ? $splitted_namespace[0] : File::Spec->catfile( @splitted_namespace );

    return $path;
}

sub _separate_namespace_name {
    my ( $self, $namespace ) = @_;

    my @splitted_name = split( /\:\:/, $namespace );

    return @splitted_name;
}

sub _convert_model_dirs_array {
    my ( $self, @dirs ) = @_;

    my $canonical_name;

    for my $dir ( @dirs ) {
        next if $dir =~ m/^\s*$/;
        $canonical_name = ( defined $canonical_name ) ? $canonical_name . '::' . $dir : $dir;
    }

    return $canonical_name;
}

sub find_models {
    my ( $self, $path_to_model, $model_path ) = @_;

    my @model_dirs = ( $model_path );

    # find all subdirs in the directory of model
    find(
        sub {
            return if ! -d $File::Find::name || $File::Find::name eq $path_to_model;
            my $dir_name = $File::Find::name;
            $dir_name =~ s/$path_to_model//; # remove path to model from directory

            # split dir path name and convert it into name like 'aaa::bbb::ccc'
            my @dirs = File::Spec->splitdir( $dir_name );
            my $canonical_dir_name = $self->_convert_model_dirs_array( @dirs );
            if ( ! $canonical_dir_name ) {
                carp "Cannot parse dir name $dir_name";
                return;
            }
            push @model_dirs, $model_path . '::' . $canonical_dir_name;
        },
        ( $path_to_model )
    );

    return \@model_dirs;
}

# recursive search and download modules with models
sub load_models {
    my ( $self, $path_to_model, $namespace, $app ) = @_;

    my $model_path = $namespace . '::' . $DEFAULT_MODEL_DIR;
    my @model_dirs = @{ $self->find_models( $path_to_model, $model_path ) };

    my $base_load_err = Mojo::Loader::load_class( $BASE_MODEL );
    croak "Loading base model $BASE_MODEL failed: $base_load_err" if ref $base_load_err;
    {
        no strict 'refs';
        *{ "$BASE_MODEL\::app" } = sub { $app };
    }

    # load modules from every dirs and subdirs of model
    for my $dir ( @model_dirs ) {
        my @model_packages = Mojo::Loader::find_modules( $dir );
        for my $pm ( @model_packages ) {
            my $load_err = Mojo::Loader::load_class( $pm );
            croak "Loading '$pm' failed: $load_err" if ref $load_err;
            my ( $basename ) = $pm =~ /$model_path\::(.*)/;
            $MODULES{ $basename } = $pm->new;
        }
    }

    return 1;
}

1;

__END__