File Coverage

blib/lib/App/mgen.pm

Criterion	Covered	Total	%
statement	86	136	63.2
branch	16	48	33.3
condition	1	8	12.5
subroutine	21	32	65.6
pod	0	2	0.0
total	124	226	54.8

package App::mgen;

use 5.008;
use utf8;
use strict;
our $VERSION = '0.16';

use Cwd;
use Carp ();
use IO::File;
use List::Util;
use File::Path;
use Pod::Usage;
use Time::Piece;
use Getopt::Long;

sub new {
    my $class = shift;

    my $self = bless {
        options => {

            # option list
            moose       => undef,
            mouse       => undef,
            moo         => undef,
            mo          => undef,
            m           => undef,
            immutable   => undef,
            autoclearn  => undef,
            signature   => undef,
            silent      => undef,
            dryrun      => undef,
            description => undef,
            author      => undef,
            email       => undef,
            path        => undef,
            current     => undef,
        },
        description => "",
        module_name => "",
        module_path => "",
        author      => "",
        email       => "",
    }, $class;

    return $self->_set_env->_set_options;
}

sub generate {
    my $self = shift;

    ## code generate

    # set header
    my $gen = $self->_gen_default;

    for my $attribute (qw/signature moose autoclearn immutable mouse moo mo m/) {
        my $call = "_gen_$attribute";
        $gen .= $self->$call if defined($self->{options}->{$attribute});
    }

    # set footer
    $gen .= $self->_gen_packend . $self->_gen_pod;

    ## file output
    my $path;
    if ( !$self->{options}->{dryrun} ) {
        if ( !$self->{options}->{current} ) {
            $path = $self->_create_dir if !$self->{options}->{current};
        } else {
            my @depth = split "::", $self->{module_name};
            $path = pop @depth;
            $path = sprintf "%s.pm", $path;
        }

        my $io = IO::File->new( $path, "w" ) || die $!;

        $io->print($gen);
        $io->close;
    }

    ## std output
    if ( !$self->{options}->{silent} ) {
        print "$gen\n";
        print "OUTPUT >> $path\n" if $path;
    }

    return $gen;
}

sub _set_env {
    my $self = shift;

    $self->{module_path} = $ENV{MGEN_ROOT}   ? $ENV{MGEN_ROOT}   : "";
    $self->{author}      = $ENV{MGEN_AUTHOR} ? $ENV{MGEN_AUTHOR} : "";
    $self->{email}       = $ENV{MGEN_EMAIL}  ? $ENV{MGEN_EMAIL}  : "";

    return $self;
}

sub _set_options {
    my $self = shift;

    # Set options
    my $options = {};
    my $ret     = GetOptions(
        'moose'         => \( $options->{moose} ),
        'mouse'         => \( $options->{mouse} ),
        'moo'           => \( $options->{moo} ),
        'mo'            => \( $options->{mo} ),
        'm'             => \( $options->{m} ),
        'immutable'     => \( $options->{immutable} ),
        'autoclearn'    => \( $options->{autoclearn} ),
        'signature'     => \( $options->{signature} ),
        'silent'        => \( $options->{silent} ),
        'dry-run'       => \( $options->{dryrun} ),
        'description=s' => \( $options->{description} ),
        'author=s'      => \( $options->{author} ),
        'email=s'       => \( $options->{email} ),
        'path=s'        => \( $options->{path} ),
        'current'       => \( $options->{current} ),
        help            => \&__pod2usage,
        version         => \&__version
    );

    # Set members
    $self->{options} = $options;

    # Set module name
    &__pod2usage unless @ARGV;
    $self->{module_name} = pop @ARGV;
    $self->{module_name} =~ s/\.pm$//g;

    # Set description
    $self->{description} = $self->{options}->{description}
      if $self->{options}->{description};

    # Set user status
    $self->{author} =
        $self->{options}->{author} ? $self->{options}->{author}
      : $self->{author}            ? $self->{author}
      :                              undef;
    $self->{email} =
        $self->{options}->{email} ? $self->{options}->{email}
      : $self->{email}            ? $self->{email}
      :                             undef;

    # If not exist path, set current directory. It is deprecated.
    $self->{module_path} = getcwd if !$self->{module_path};
    $self->{module_path} = $self->{options}->{path} if $self->{options}->{path};

    return $self;
}

sub _create_dir {
    my $self = shift;

    return if !$self->{module_path};

    my $module_name = $self->{module_name};
    $module_name =~ s/::/\//g;

    my ( $path, $file_path );
    $path = $file_path = sprintf "%s/%s", $self->{module_path}, $module_name;

    $path =~ s/\/\///g;                               # remove duplicates
    $path =~ s/\/\w+$//g;                             # remove module name
    $_    =~ s/[\r\n]//g for ( $path, $file_path );

    eval { mkpath($path); };
    if ($@) {
        Carp::croak "failed create directory : $@\n";
    }

    return "$file_path.pm";
}

sub _gen_pod {
    my $self = shift;

    my $name        = $self->_gen_name;
    my $author      = $self->_gen_author;
    my $description = $self->_gen_description;

    my $pod = <<"GEN_POD";
__END__