File Coverage

blib/lib/Time/Piece/Plus.pm

Criterion	Covered	Total	%
statement	115	115	100.0
branch	32	36	88.8
condition	2	3	66.6
subroutine	29	29	100.0
pod	10	15	66.6
total	188	198	94.9

package Time::Piece::Plus;
use strict;
use warnings;
use 5.010_001;

our $VERSION = '0.05';

use parent qw/Time::Piece/;

use Scalar::Util ();

sub import {
    my $class  = shift;
    my $caller = caller;
    for my $method (qw(localtime gmtime)) {
        my $code = sub {
            my $invocant = $_[0] && Scalar::Util::blessed($_[0]) ? shift : $class;
            $invocant->$method(@_)
        };
        {
            no strict 'refs';
            *{"$caller\::$method"} = $code; ## no critic
        }
    }
}

use Time::Seconds;
use Data::Validator;

sub get_object {
    my $invocant = shift;

    my $object = ref $invocant ? $invocant : $invocant->localtime;
    return $object;
}

sub reparse {
    state $validator = Data::Validator->new(
        format_string => {isa => 'Str'},
        parse_string  => {isa => 'Str', default => sub{$_[2]->{format_string}}},
    )->with(qw(Method));
    my ($self, $args) = $validator->validate(@_);

    $self->strptime($self->strftime($args->{format_string}), $args->{parse_string});
}

sub get_is_local {
    my $invocant = shift;

    return ref $invocant ? $invocant->[10] : 1;
}

sub get_time_diff {
    my $self = shift;
    return $self->sec + $self->min * 60 + $self->hour * 3600;
}

sub get_method_name {
    my $invocant = shift;

    return $invocant->get_is_local ? 'localtime' : 'gmtime';
 }

sub yesterday {
    my $invocant = shift;

    my $self   = $invocant->get_object;
    my $epoch  = $self->epoch;
    my $method = $self->get_method_name;

    $self->$method($epoch - ONE_DAY - $self->get_time_diff);
}

sub tomorrow {
    my $invocant = shift;

    my $self   = $invocant->get_object;
    my $epoch  = $self->epoch;
    my $method = $self->get_method_name;

    $invocant->$method($epoch + ONE_DAY - $self->get_time_diff);
}

sub today {
    my $invocant = shift;

    my $self   = $invocant->get_object;
    my $epoch  = $self->epoch;
    my $method = $self->get_method_name;

    $invocant->$method($epoch - $self->get_time_diff);
}

my %TRUNCATE_FORMAT = (
    minute  => '%Y%m%d%H%M00',
    hour    => '%Y%m%d%H0000',
    day     => '%Y%m%d000000',
    month   => '%Y%m01000000',
    year    => '%Y0101000000',
);

use Mouse::Util::TypeConstraints;

enum 'Time::Piece::Plus::ColumTypes' => keys %TRUNCATE_FORMAT;

no Mouse::Util::TypeConstraints;

sub truncate {
    state $validator = Data::Validator->new(
        to => {isa => 'Time::Piece::Plus::ColumTypes'},
    )->with(qw(Method));
    my ($self, $args) = $validator->validate(@_);
    my $format = $TRUNCATE_FORMAT{$args->{to}};
    $self = $self->get_object;
    return $self->reparse(format_string => $format);
}

sub parse_mysql_date {
    state $validator = Data::Validator->new(
        str          => {isa => 'Str'},
        as_localtime => {isa => 'Bool', default => 1},
    )->with(qw(Method));
    my ($class, $args) = $validator->validate(@_);

    return if $args->{str} eq "0000-00-00";

    my $self = $args->{as_localtime} ? $class->localtime() : $class->gmtime();
    my $parsed = $self->strptime($args->{str}, '%Y-%m-%d');

    return $parsed;
}

sub parse_mysql_datetime {
    state $validator = Data::Validator->new(
        str => {isa => 'Str'},
        as_localtime => {isa => 'Bool', default => 1},
    )->with(qw(Method));
    my ($class, $args) = $validator->validate(@_);

    return if $args->{str} eq "0000-00-00 00:00:00";

    my $self = $args->{as_localtime} ? $class->localtime() : $class->gmtime();
    my $parsed = $self->strptime($args->{str}, '%Y-%m-%d %H:%M:%S');

    return $parsed;
}

sub mysql_date {
    my ($self, ) = @_;
    $self = $self->get_object;
    return $self->strftime("%Y-%m-%d");
}
sub mysql_datetime {
    my ($self, ) = @_;
    $self = $self->get_object;
    return $self->strftime("%Y-%m-%d %H:%M:%S");
}

sub add {
    my ($self, @args) = @_;
    return $self->SUPER::add(@args) if @args <= 1;

    my %args = @args;
    my $seconds = $self->_calc_seconds(%args);
    $self = $self->SUPER::add($seconds);

    $self = $self->add_months($args{months}) if $args{months};
    $self = $self->add_years($args{years})   if $args{years};

    $self;
}

sub subtract {
    my ($self, @args) = @_;
    return $self->SUPER::subtract(@args) if @args <= 1;

    my %args = @args;
    my $seconds = $self->_calc_seconds(%args);
    $self = $self->SUPER::subtract($seconds);

    $self = $self->add_months(-1 * $args{months}) if $args{months};
    $self = $self->add_years(-1 * $args{years})   if $args{years};

    $self;
}

sub _calc_seconds {
    my $self = shift;

    state $validator = Data::Validator->new(
        seconds => {isa => 'Int', optional => 1},
        minutes => {isa => 'Int', optional => 1},
        hours   => {isa => 'Int', optional => 1},
        days    => {isa => 'Int', optional => 1},
        months  => {isa => 'Int', optional => 1},
        years   => {isa => 'Int', optional => 1},
    );
    my $args = $validator->validate(@_);

    my $seconds = 0;
    $seconds += $args->{seconds}              if exists $args->{seconds};
    $seconds += ONE_MINUTE * $args->{minutes} if exists $args->{minutes};
    $seconds += ONE_HOUR   * $args->{hours}   if exists $args->{hours};
    $seconds += ONE_DAY    * $args->{days}    if exists $args->{days};

    $seconds;
}


1;
__END__