File Coverage

blib/lib/DateTime/Format/Human/Duration.pm

Criterion	Covered	Total	%
statement	59	66	89.3
branch	42	50	84.0
condition			n/a
subroutine	6	6	100.0
pod	3	3	100.0
total	110	125	88.0

package DateTime::Format::Human::Duration;

use warnings;
use strict;
require DateTime::Format::Human::Duration::Locale;

our $VERSION = '0.61';

use Carp qw/croak/;

sub new {
    bless { 'locale_cache' => {} }, 'DateTime::Format::Human::Duration';
}

sub format_duration_between {
    my ($span, $dt, $dtb, %args) = @_;
    my $dur = $dt - $dtb;

    if (!exists $args{'locale'}) {
        $args{'locale'} = $dt->{'locale'}{'id'};
    }

    return $span->format_duration($dur, %args);
}

sub format_duration {
    my ($span, $duration, %args) = @_;

    my @default_units = qw(years months weeks days hours minutes seconds nanoseconds);

    my @units = $args{'units'} ? @{ $args{'units'} } : @default_units;
    if ($args{'precision'}) {
        # Reduce time resolution to requested precision
        for (my $i = 0; $i < scalar(@units); $i++) {
            next unless ($units[$i] eq $args{'precision'});
            splice(@units, $i + 1);
        }
        croak('Useless precision') unless (@units);
    }

    my @duration_vals = $duration->in_units( @units );
    my $i = 0;
    my %duration_vals = map { ($_ => $duration_vals[$i++]) } @units;
    my %positive_duration_vals = map { ($_ => abs $duration_vals{$_}) } keys %duration_vals;

    my $say = '';

    # $dta - $dtb:
    #   if dta < dtb means past -> future (Duration units will have negatives)
    #   else its either this absolute instant (no_time) or the past
    if ( grep { $_ < 0 } @duration_vals ) {
        if ( exists $args{'future'} ) {
            $say = $args{'future'}
        }
    }
    else {
        if ( exists $args{'past'} ) {
            $say = $args{'past'}
        }
    }

    ####
    ## this is essentially the hashref that is returned from DateTime::Format::Human::Duration::en::get_human_span_hashref() : #
    ####
    my $setup = {
        'no_oxford_comma' => 0,
        'no_time' => 'no time', # The wait will be $formatted_duration
        'and'     => 'and',
        'year'  => 'year',
        'years' => 'years',
        'month'  => 'month',
        'months' => 'months',
        'week'  => 'week',
        'weeks' => 'weeks',
        'day'  => 'day',
        'days' => 'days',
        'hour'  => 'hour',
        'hours' => 'hours',
        'minute'  => 'minute',
        'minutes' => 'minutes',
        'second'  => 'second',
        'seconds' => 'seconds',
        'nanosecond'  => 'nanosecond',
        'nanoseconds' => 'nanoseconds',
    };

    my $locale = DateTime::Format::Human::Duration::Locale::calc_locale($span, $args{'locale'});

    if($locale) {
        if ( ref $locale eq 'HASH' ) {
            %{ $setup } = (
                %{ $setup },
                %{ $locale },
            );
        }
        # get_human_span_from_units_array is deprecated, but we will still
        # support it.
        elsif ( my $get1 = $locale->can('get_human_span_from_units_array') ) {
            my @n = map { $positive_duration_vals{$_} } @default_units;
            return $get1->( @n, \%args );
        }
        elsif ( my $get2 = $locale->can('get_human_span_from_units') ) {
            return $get2->( \%duration_vals, \%args );
        }
    }

    my @parts;
    for my $unit (@units) {
        my $val = $positive_duration_vals{$unit};
        next unless $val;

        my $setup_key = $unit;
        if ($val == 1) {
            $setup_key =~ s/s$//;
        }

        push(@parts, $val . ' ' . $setup->{$setup_key});
        if (exists $args{'significant_units'}) {
            last if scalar(@parts) == $args{'significant_units'};
        }
    }

    my $no_time = exists $args{'no_time'} ? $args{'no_time'} : $setup->{'no_time'};
    return $no_time if !@parts;

    my $last = @parts > 1 ? pop(@parts): '';

    ## We want to use the so-called Oxford comma to avoid ambiguity.
    ## For that reason we make locale's specifically tell us they do not want it.
    my $string = $setup->{'no_oxford_comma'}
        ? join(', ', @parts) . ($last ? " $setup->{'and'} $last" : '')
        : join(', ', @parts) . (@parts > 1  ? ',' : '') . ($last ? " $setup->{'and'} $last" : '')
        ;

    if ( $say ) {
       $string = $say =~ m{%s} ? sprintf($say, $string): "$say $string";
    }

    return $string;
}

1;

__END__