File Coverage

blib/lib/File/Find/Rule/Age.pm

Criterion	Covered	Total	%
statement	131	179	73.1
branch	70	102	68.6
condition	26	39	66.6
subroutine	50	70	71.4
pod	0	13	0.0
total	277	403	68.7

package File::Find::Rule::Age;

use strict;
use warnings;

our $VERSION = "0.302";

use base "File::Find::Rule";

use Carp 'carp';
use DateTime;
use File::stat;
use Params::Util qw(_STRING _NONNEGINT _INSTANCE);

my %mapping = (
    "D" => "days",
    "W" => "weeks",
    "M" => "months",
    "Y" => "years",
    "h" => "hours",
    "m" => "minutes",
    "s" => "seconds",
);

my %criteria = (
    older => 1,
    newer => 1,
);

sub File::Find::Rule::age
{
    my ( $me, $criterion, $age ) = @_;
    my ( $interval, $unit ) = ( $age =~ m/^(\d+)([DWMYhms])$/ );
    return carp "Duration or Unit missing" unless ( $interval and $unit );

    $criterion = lc($criterion);
    defined $criteria{$criterion} or return carp "Invalid criterion: $criterion";

    my $self     = $me->_force_object;
    my $sub2exec = $criterion eq "older"
      ? sub {
        my $dt = DateTime->now;
        $dt->subtract( $mapping{$unit} => $interval );
        stat($_)->mtime < $dt->epoch;
      }
      : sub {
        my $dt = DateTime->now;
        $dt->subtract( $mapping{$unit} => $interval );
        stat($_)->mtime > $dt->epoch;
      };
    $self->exec($sub2exec);
}

sub File::Find::Rule::modified_before
{
    my ( $me, $ts ) = @_;

    my $self = $me->_force_object;
    _STRING($ts) and -e $ts and return $self->exec(
        sub {
            stat($_)->mtime < stat($ts)->mtime;
        }
    );

    _NONNEGINT($ts) and return $self->exec(
        sub {
            stat($_)->mtime < $ts;
        }
    );
    _INSTANCE( $ts, "DateTime" ) and return $self->exec(
        sub {
            stat($_)->mtime < $ts->epoch;
        }
    );
    _INSTANCE( $ts, "DateTime::Duration" ) and return $self->exec(
        sub {
            my $dt = DateTime->now() - $ts;
            stat($_)->mtime < $dt->epoch;
        }
    );
    carp "Cannot parse reference";
}

sub File::Find::Rule::modified_until
{
    my ( $me, $ts ) = @_;

    my $self = $me->_force_object;
    _STRING($ts) and -e $ts and return $self->exec(
        sub {
            stat($_)->mtime <= stat($ts)->mtime;
        }
    );

    _NONNEGINT($ts) and return $self->exec(
        sub {
            stat($_)->mtime <= $ts;
        }
    );
    _INSTANCE( $ts, "DateTime" ) and return $self->exec(
        sub {
            stat($_)->mtime <= $ts->epoch;
        }
    );
    _INSTANCE( $ts, "DateTime::Duration" ) and return $self->exec(
        sub {
            my $dt = DateTime->now() - $ts;
            stat($_)->mtime <= $dt->epoch;
        }
    );
    carp "Cannot parse reference";
}

sub File::Find::Rule::modified_since
{
    my ( $me, $ts ) = @_;

    my $self = $me->_force_object;
    _STRING($ts) and -e $ts and return $self->exec(
        sub {
            stat($_)->mtime >= stat($ts)->mtime;
        }
    );

    _NONNEGINT($ts) and return $self->exec(
        sub {
            stat($_)->mtime >= $ts;
        }
    );
    _INSTANCE( $ts, "DateTime" ) and return $self->exec(
        sub {
            stat($_)->mtime >= $ts->epoch;
        }
    );
    _INSTANCE( $ts, "DateTime::Duration" ) and return $self->exec(
        sub {
            my $dt = DateTime->now() - $ts;
            stat($_)->mtime >= $dt->epoch;
        }
    );
    carp "Cannot parse reference";
}

sub File::Find::Rule::modified_after
{
    my ( $me, $ts ) = @_;

    my $self = $me->_force_object;
    _STRING($ts) and -e $ts and return $self->exec(
        sub {
            stat($_)->mtime > stat($ts)->mtime;
        }
    );

    _NONNEGINT($ts) and return $self->exec(
        sub {
            stat($_)->mtime > $ts;
        }
    );
    _INSTANCE( $ts, "DateTime" ) and return $self->exec(
        sub {
            stat($_)->mtime > $ts->epoch;
        }
    );
    _INSTANCE( $ts, "DateTime::Duration" ) and return $self->exec(
        sub {
            my $dt = DateTime->now() - $ts;
            stat($_)->mtime > $dt->epoch;
        }
    );
    carp "Cannot parse reference";
}

#############################################################################

sub File::Find::Rule::accessed_before
{
    my ( $me, $ts ) = @_;

    my $self = $me->_force_object;
    _STRING($ts) and -e $ts and return $self->exec(
        sub {
            stat($_)->atime < stat($ts)->atime;
        }
    );

    _NONNEGINT($ts) and return $self->exec(
        sub {
            stat($_)->atime < $ts;
        }
    );
    _INSTANCE( $ts, "DateTime" ) and return $self->exec(
        sub {
            stat($_)->atime < $ts->epoch;
        }
    );
    _INSTANCE( $ts, "DateTime::Duration" ) and return $self->exec(
        sub {
            my $dt = DateTime->now() - $ts;
            stat($_)->atime < $dt->epoch;
        }
    );
    carp "Cannot parse reference";
}

sub File::Find::Rule::accessed_until
{
    my ( $me, $ts ) = @_;

    my $self = $me->_force_object;
    _STRING($ts) and -e $ts and return $self->exec(
        sub {
            stat($_)->atime <= stat($ts)->atime;
        }
    );

    _NONNEGINT($ts) and return $self->exec(
        sub {
            stat($_)->atime <= $ts;
        }
    );
    _INSTANCE( $ts, "DateTime" ) and return $self->exec(
        sub {
            stat($_)->atime <= $ts->epoch;
        }
    );
    _INSTANCE( $ts, "DateTime::Duration" ) and return $self->exec(
        sub {
            my $dt = DateTime->now() - $ts;
            stat($_)->atime <= $dt->epoch;
        }
    );
    carp "Cannot parse reference";
}

sub File::Find::Rule::accessed_since
{
    my ( $me, $ts ) = @_;

    my $self = $me->_force_object;
    _STRING($ts) and -e $ts and return $self->exec(
        sub {
            stat($_)->atime >= stat($ts)->atime;
        }
    );

    _NONNEGINT($ts) and return $self->exec(
        sub {
            stat($_)->atime >= $ts;
        }
    );
    _INSTANCE( $ts, "DateTime" ) and return $self->exec(
        sub {
            stat($_)->atime >= $ts->epoch;
        }
    );
    _INSTANCE( $ts, "DateTime::Duration" ) and return $self->exec(
        sub {
            my $dt = DateTime->now() - $ts;
            stat($_)->atime >= $dt->epoch;
        }
    );
    carp "Cannot parse reference";
}

sub File::Find::Rule::accessed_after
{
    my ( $me, $ts ) = @_;

    my $self = $me->_force_object;
    _STRING($ts) and -e $ts and return $self->exec(
        sub {
            stat($_)->atime > stat($ts)->atime;
        }
    );

    _NONNEGINT($ts) and return $self->exec(
        sub {
            stat($_)->atime > $ts;
        }
    );
    _INSTANCE( $ts, "DateTime" ) and return $self->exec(
        sub {
            stat($_)->atime > $ts->epoch;
        }
    );
    _INSTANCE( $ts, "DateTime::Duration" ) and return $self->exec(
        sub {
            my $dt = DateTime->now() - $ts;
            stat($_)->atime > $dt->epoch;
        }
    );
    carp "Cannot parse reference";
}

#############################################################################

sub File::Find::Rule::created_before
{
    my ( $me, $ts ) = @_;

    my $self = $me->_force_object;
    _STRING($ts) and -e $ts and return $self->exec(
        sub {
            stat($_)->ctime < stat($ts)->ctime;
        }
    );

    _NONNEGINT($ts) and return $self->exec(
        sub {
            stat($_)->ctime < $ts;
        }
    );
    _INSTANCE( $ts, "DateTime" ) and return $self->exec(
        sub {
            stat($_)->ctime < $ts->epoch;
        }
    );
    _INSTANCE( $ts, "DateTime::Duration" ) and return $self->exec(
        sub {
            my $dt = DateTime->now() - $ts;
            stat($_)->ctime < $dt->epoch;
        }
    );
    carp "Cannot parse reference";
}

sub File::Find::Rule::created_until
{
    my ( $me, $ts ) = @_;

    my $self = $me->_force_object;
    _STRING($ts) and -e $ts and return $self->exec(
        sub {
            stat($_)->ctime <= stat($ts)->ctime;
        }
    );

    _NONNEGINT($ts) and return $self->exec(
        sub {
            stat($_)->ctime <= $ts;
        }
    );
    _INSTANCE( $ts, "DateTime" ) and return $self->exec(
        sub {
            stat($_)->ctime <= $ts->epoch;
        }
    );
    _INSTANCE( $ts, "DateTime::Duration" ) and return $self->exec(
        sub {
            my $dt = DateTime->now() - $ts;
            stat($_)->ctime <= $dt->epoch;
        }
    );
    carp "Cannot parse reference";
}

sub File::Find::Rule::created_since
{
    my ( $me, $ts ) = @_;

    my $self = $me->_force_object;
    _STRING($ts) and -e $ts and return $self->exec(
        sub {
            stat($_)->ctime >= stat($ts)->ctime;
        }
    );

    _NONNEGINT($ts) and return $self->exec(
        sub {
            stat($_)->ctime >= $ts;
        }
    );
    _INSTANCE( $ts, "DateTime" ) and return $self->exec(
        sub {
            stat($_)->ctime >= $ts->epoch;
        }
    );
    _INSTANCE( $ts, "DateTime::Duration" ) and return $self->exec(
        sub {
            my $dt = DateTime->now() - $ts;
            stat($_)->ctime >= $dt->epoch;
        }
    );
    carp "Cannot parse reference";
}

sub File::Find::Rule::created_after
{
    my ( $me, $ts ) = @_;

    my $self = $me->_force_object;
    _STRING($ts) and -e $ts and return $self->exec(
        sub {
            stat($_)->ctime > stat($ts)->ctime;
        }
    );

    _NONNEGINT($ts) and return $self->exec(
        sub {
            stat($_)->ctime > $ts;
        }
    );
    _INSTANCE( $ts, "DateTime" ) and return $self->exec(
        sub {
            stat($_)->ctime > $ts->epoch;
        }
    );
    _INSTANCE( $ts, "DateTime::Duration" ) and return $self->exec(
        sub {
            my $dt = DateTime->now() - $ts;
            stat($_)->ctime > $dt->epoch;
        }
    );
    carp "Cannot parse reference";
}

#############################################################################

1;
__END__