File Coverage

blib/lib/Badger/Duration.pm

Criterion	Covered	Total	%
statement	57	61	93.4
branch	11	18	61.1
condition	10	20	50.0
subroutine	7	8	87.5
pod	7	7	100.0
total	92	114	80.7

package Badger::Duration;

use Badger::Class
    version   => 0.01,
    debug     => 0,
    base      => 'Badger::Comparable',
    import    => 'CLASS',
    utils     => 'numlike is_object params inflect',
    as_text   => 'text',
    is_true   => 1,
    accessors => 'duration seconds',
    constants => 'HASH DELIMITER',
    constant  => {
        DURATION => 'Badger::Duration',
    },
    exports   => {
        any   => 'DURATION Duration',
    };

our $SECONDS = {
    second => 1,
    minute => 60,
    hour   => 60*60,
    day    => 60*60*24,
    week   => 60*60*24*7,
    month  => 60*60*24*30,
    year   => 60*60*24*365,
};

our $ALIAS_LIST = {
    second  => 's sec secs second seconds',
    minute  => 'm min mins minute minutes',
    hour    => 'h hr hrs hour hours',
    day     => 'd day days',
    week    => 'w wk week weeks',
    month   => 'M mon mons month months',
    year    => 'y yr yrs year years',
};

our $ALIASES = {
    map {
        my $key     = $_;
        my $aliases = $ALIAS_LIST->{ $key };
        map { $_ => $key }
        split(/\s+/, $aliases);
    }
    keys %$ALIAS_LIST
};

our @ORDER = qw( year month day hour minute second );


sub Duration {
    return DURATION unless @_;
    if (@_ == 1) {
        if (is_object(DURATION, $_[0])) {
            return $_[0];
        }
        else {
            return DURATION->new( duration => $_[0] );
        }
    }
    else {
        return DURATION->new( duration => params(@_) );
    }
}

sub init {
    my ($self, $config) = @_;
    my $duration = $config->{ duration } || $config;

    $self->debug(
        "init() : ", $self->dump_data($duration)
    ) if DEBUG;

    if (ref $duration eq HASH) {
        $duration = $self->parse_hash($duration);
    }
    else {
        $duration = $self->parse_text($duration);
    }

    $self->{ seconds  } = $self->count_seconds($duration);
    $self->{ duration } = $duration;

    return $self;
}

sub parse_text {
    my ($self, $duration) = @_;
    my $bits  = { };

    # $duration can be a number, assumed to be seconds
    return { seconds => $duration }
        if numlike($duration);

    while ($duration =~ /\G\s*(-?[\d\.]+)\s*(\w+)\s*(,|and)?\s*/gc) {
        $self->debug("PARSE [$1] [$2]") if DEBUG;
        my $name = $ALIASES->{ $2 } || $ALIASES->{ lc $2 }
            || return $self->error_msg( invalid => duration => "$1 $2" );
        my $old = $bits->{ $name } || 0;
        my $new = $1;
        return $self->error_msg( invalid => duration => "$1 $2" )
            unless numlike($new);
        $bits->{ $name } += $new;
        $self->debug("+ $new $name") if DEBUG;
    }

    if ($duration =~ /\G\s*(.*)/gc && length $1) {
        return $self->error_msg( invalid => duration => $1 );
    }

    return $bits;
}

sub parse_hash {
    my ($self, $duration) = @_;
    my $bits  = { };

    while (my ($key, $value) = each %$duration) {
        my $name = $ALIASES->{ $key } || $ALIASES->{ lc $key }
            || return $self->error_msg( invalid => duration => $key );
        my $old = $bits->{ $name } || 0;
        return $self->error_msg( invalid => duration => "$key => $value" )
            unless numlike($value);
        $bits->{ $name } += $value;
        $self->debug("+ $value $name") if DEBUG;
    }
    return $bits;
}

sub count_seconds {
    my ($self, $bits) = @_;
    my $seconds = 0;

    while (my ($key, $value) = each %$bits) {
        my $name = $ALIASES->{ $key } || $ALIASES->{ lc $key }
            || return $self->error_msg( invalid => duration => $key );
        $self->debug("COUNT [$key => $name] [$value]") if DEBUG;
        my $secs = $SECONDS->{ $name }
            || return $self->error_msg( invalid => duration => "$key -> $name" );
        return $self->error_msg( invalid => duration => "$value $key" )
            unless numlike($value);
        $seconds += $secs * $value;
    }

    return $seconds;
}

sub compare {
    my ($this, $that) = @_;
    return $this->{ seconds } <=> $that->{ seconds };
}

sub text {
    my $self     = shift;
    my $duration = $self->{ duration };
    my @bits;

    $self->debug("DURATION: ", $self->dump_data($duration)) if DEBUG;

    foreach my $item (@ORDER) {
        my $value = $duration->{ $item } || next;
        push(@bits, inflect($value, $item));
        $self->debug("DURATION + $value $item") if DEBUG;
    }
    return join(' ', @bits);
}



1;
__END__