File Coverage

blib/lib/Time/ETA.pm

Criterion	Covered	Total	%
statement	144	144	100.0
branch	60	60	100.0
condition			n/a
subroutine	26	26	100.0
pod	14	14	100.0
total	244	244	100.0

package Time::ETA;
{
  $Time::ETA::VERSION = '1.1.1';
}

# ABSTRACT: calculate estimated time of accomplishment


use warnings;
use strict;

use Carp;
use Time::HiRes qw(
    gettimeofday
    tv_interval
);

use YAML;

my $true = 1;
my $false = '';

our $SERIALIZATION_API_VERSION = 3;


sub new {
    my ($class, %params) = @_;
    my $self = {};
    bless $self, $class;

    croak "Expected to get parameter 'milestones'. Stopped" if not defined $params{milestones};
    croak "Parameter 'milestones' should be positive integer. Stopped" if not $self->_is_positive_integer($params{milestones});

    $self->{_milestones} = $params{milestones};
    $self->{_passed_milestones} = 0;
    $self->{_elapsed} = 0;
    $self->{_start} = [gettimeofday];
    $self->{_is_paused} = $false;

    return $self;
}


sub get_elapsed_seconds {
    my ($self) = @_;

    my $elapsed_seconds;

    if ($self->is_completed()) {
        $elapsed_seconds = tv_interval($self->{_start}, $self->{_end});
    } else {
        $elapsed_seconds = tv_interval($self->{_start}, [gettimeofday]);
    }

    return $elapsed_seconds;
}


sub get_remaining_seconds {
    my ($self) = @_;

    croak "There is not enough data to calculate estimated time of accomplishment. Stopped" if not $self->can_calculate_eta();

    return 0 if $self->is_completed();

    my $elapsed_before_milestone = tv_interval($self->{_start}, $self->{_milestone_pass});
    my $elapsed_after_milestone = tv_interval($self->{_milestone_pass}, [gettimeofday()]);

    my $remaining_milestones = $self->{_milestones} - $self->{_passed_milestones};

    my $one_milestone_completion_time = $elapsed_before_milestone/$self->{_passed_milestones};
    my $remaining_seconds = ($one_milestone_completion_time * $remaining_milestones) - $elapsed_after_milestone;

    return $remaining_seconds;
}


sub get_remaining_time {
    my ($self) = @_;

    my $time = $self->_get_time_from_seconds($self->get_remaining_seconds());

    return $time;
}


sub get_completed_percent {
    my ($self) = @_;

    my $completed_percent = (100 * $self->{_passed_milestones}) / $self->{_milestones};

    return $completed_percent;
}


sub is_completed {
    my ($self) = @_;

    return ($self->{_passed_milestones} == $self->{_milestones})
        ? $true
        : $false
        ;
}


sub pass_milestone {
    my ($self) = @_;

    if ($self->{_passed_milestones} < $self->{_milestones}) {
        $self->{_passed_milestones}++;
    } else {
        croak "You have already completed all milestones. It it incorrect to run pass_milestone() now. Stopped";
    }

    my $dt = [gettimeofday];

    $self->{_milestone_pass} = $dt;

    if ($self->{_passed_milestones} == $self->{_milestones}) {
        $self->{_end} = $dt;
    }

    return $false;
}


sub can_calculate_eta {
    my ($self) = @_;

    if ($self->{_passed_milestones} > 0) {
        return $true;
    } else {
        return $false;
    }
}


sub pause {
    my ($self) = @_;

    croak "The object is already paused. Can't pause paused. Stopped" if $self->is_paused();

    my $elapsed_seconds = tv_interval($self->{_start}, [gettimeofday]);
    $self->{_elapsed} += $elapsed_seconds;
    $self->{_start} = undef;

    $self->{_is_paused} = $true;

    return $false;
}


sub is_paused {
    my ($self) = @_;

    return $self->{_is_paused};
}


sub resume {
    my ($self, $string) = @_;

    croak "The object isn't paused. Can't resume. Stopped" if not $self->is_paused();

    # Setting the start time
    # Start time is the current time minus time that has already pass
    my $timeofday = [gettimeofday];
    my $start = ($timeofday->[0] * 1_000_000 + $timeofday->[1]) - int($self->{_elapsed} * 1_000_000);
    $self->{_start} = [int($start / 1_000_000), $start % 1_000_000];

    $self->{_elapsed} = 0;
    $self->{_is_paused} = $false;

    return $false;
}


sub serialize {
    my ($self) = @_;

    my $data = {
        _version => $SERIALIZATION_API_VERSION,
        _milestones => $self->{_milestones},
        _passed_milestones => $self->{_passed_milestones},
        _start  => $self->{_start},
        _milestone_pass => $self->{_milestone_pass},
        _end  => $self->{_end},
        _is_paused => $self->{_is_paused},
        _elapsed => $self->{_elapsed},
    };

    my $string = Dump($data);

    return $string;
}


sub spawn {
    my ($class, $string) = @_;

    croak "Can't spawn Time::ETA object. No serialized data specified. Stopped" if not defined $string;

    my $data;

    eval {
        $data = Load($string);
    };

    if ($@) {
        croak "Can't spawn Time::ETA object. Got error from YAML parser:\n" . $@ . "Stopped";
    }

    croak "Can't spawn Time::ETA object. Got incorrect serialized data. Stopped" if ref $data ne "HASH";

    croak "Can't spawn Time::ETA object. Serialized data does not contain version. Stopped" if not defined $data->{_version};

    my $v = _get_version();
    croak "Can't spawn Time::ETA object. Version $v can work only with serialized data version $SERIALIZATION_API_VERSION. Stopped"
        if $data->{_version} ne $SERIALIZATION_API_VERSION;

    croak "Can't spawn Time::ETA object. Serialized data contains incorrect number of milestones. Stopped"
        if not _is_positive_integer(undef, $data->{_milestones});

    croak "Can't spawn Time::ETA object. Serialized data contains incorrect number of passed milestones. Stopped"
        if not _is_positive_integer_or_zero(undef, $data->{_passed_milestones});

    if (not $data->{_is_paused}) {
        _check_gettimeofday(
            undef,
            value => $data->{_start},
            name => "start time"
        );
    }

    if (defined $data->{_end}) {
        _check_gettimeofday(
            undef,
            value => $data->{_end},
            name => "end time"
        );
    }

    if (defined $data->{_milestone_pass}) {
        _check_gettimeofday(
            undef,
            value => $data->{_milestone_pass},
            name => "last milestone pass time"
        );
    }

    my $self = {
        _milestones => $data->{_milestones},
        _passed_milestones => $data->{_passed_milestones},
        _start  => $data->{_start},
        _milestone_pass => $data->{_milestone_pass},
        _end  => $data->{_end},
        _is_paused => $data->{_is_paused},
        _elapsed => $data->{_elapsed},
    };

    bless $self, $class;

    return $self;
}


sub can_spawn {
    my ($class, $string) = @_;

    eval {
        my $eta = spawn($class, $string);
    };

    if (not $@) {
        return $true;
    } else {
        return $false;
    }
}

sub _check_gettimeofday {
    my ($self, %params) = @_;

    croak "Expected to get 'name'" unless defined $params{name};

    croak "Can't spawn Time::ETA object. Serialized data contains incorrect data for $params{name}. Stopped"
        if ref $params{value} ne "ARRAY";

    croak "Can't spawn Time::ETA object. Serialized data contains incorrect seconds in $params{name}. Stopped"
        if not _is_positive_integer_or_zero(undef, $params{value}->[0]);

    croak "Can't spawn Time::ETA object. Serialized data contains incorrect microseconds in $params{name}. Stopped"
        if not _is_positive_integer_or_zero(undef, $params{value}->[1]);

    return $false;
}

sub _is_positive_integer_or_zero {
    my ($self, $maybe_number) = @_;

    return $false if not defined $maybe_number;

    # http://www.perlmonks.org/?node_id=614452
    my $check_result = $maybe_number =~ m{
        \A      # beginning of string
        \+?     # optional plus sign
        [0-9]+  # mandatory digits, including zero
        \z      # end of string
    }xms;

    return $check_result;
}

sub _is_positive_integer {
    my ($self, $maybe_number) = @_;

    return $false if not defined $maybe_number;

    return $false if $maybe_number eq '0';
    return $false if $maybe_number eq '+0';

    return _is_positive_integer_or_zero(undef, $maybe_number);
}

sub _get_time_from_seconds {
    my ($self, $input_sec) = @_;

    my $text;
    {
        # This is a quick solution. This like make code more robust.
        # With this like the code will fail if $input_sec is not a number.
        use warnings FATAL => 'all';

        my $left_sec;
        my $hour = int($input_sec/3600);
        $left_sec = $input_sec - ($hour * 3600);

        my $min = int($left_sec/60);
        $left_sec = $left_sec - ($min * 60);

        $text =
            sprintf("%01d", $hour) . ":"
            . sprintf("%02d", $min) . ":"
            . sprintf("%02d", $left_sec)
            ;
    }

    return $text;
}


sub _get_version {
    no warnings 'uninitialized';
    my $v = "$Time::ETA::VERSION";
    return $v;
}


1;

__END__