view release on metacpan or  search on metacpan

lib/Dir/Split.pm  view on Meta::CPAN

use boolean qw(true false);

use Carp qw(croak);
use File::Basename ();
use File::Copy ();
use File::Find ();
use File::Path ();
use File::Spec ();
use Params::Validate ':all';

our $VERSION = '0.82';

validation_options(
    on_fail => sub
{
    my ($error) = @_;
    chomp $error;
    croak $error;
},
    stack_skip => 2,
);

my %num_presets = (
    verbose   => false,
    override  => false,
    sort      => 'asc',
    limit     => 5,
    prefix    => 'sub',
    separator => '-',
    continue  => false,
    length    => 5,
);
my %char_presets = (
    verbose   => false,
    override  => false,
    prefix    => 'sub',
    separator => '-',
    case      => 'upper',
    length    => 1,
);

sub new
{
    my $class = shift;

    my $self = bless {}, ref($class) || $class;

    $self->_init(@_);

    return $self;
}

sub _init
{
    my $self = shift;
    my %opts = @_;

    validate(@_, {
        source => {
            type => SCALAR,
            callbacks => {
                'directory exists' => sub { -d $_[0] }
            },
        },
        target => {
            type => SCALAR,
            callbacks => {
                'directory exists' => sub { -d $_[0] }
            },
        },
    });

    foreach my $opt (qw(source target)) {
        $self->{ucfirst $opt} = $opts{$opt};
    }
}

sub split_num
{
    my $self = shift;

    $self->_validate_num(@_);

    $self->_init_mode(@_, \%num_presets);

    my ($dirs, $files) = $self->_gather_files;
    $self->_sort_files($files);

    my $suffix = $self->_get_num_suffix;
    $self->_move_num($files, $suffix);
}

sub _validate_num
{
    my $self = shift;

    validate(@_, {
        verbose => {
            type => BOOLEAN,
            optional => true,
        },
        override => {
            type => BOOLEAN,
            optional => true,
        },
        sort => {
            type => SCALAR,
            optional => true,
            regex => qr!^(?:asc|desc)$!,
        },
        limit => {
            type => SCALAR,
            optional => true,
            regex => qr!^\d+$!,
        },
        prefix => {
            type => SCALAR,
            optional => true,
            regex => qr!^\S+$!,
        },
        separator => {
            type => SCALAR,
            optional => true,
            regex => qr!^\S+$!,
        },
        continue => {
            type => BOOLEAN,