lib/DateTime/Lite/Duration.pm

filter: Statementstmt 63.7% 162 / 254 Branchbran 38.2% 49 / 128 Conditioncond 10.1% 9 / 89 MC/DCmcdc 6.3% 3 / 47 Subroutinesub 78.3% 47 / 60 Podpod 100% 35 / 35 totaltotal 49.7% 305 / 613 CC 105 SCAR 57.4
CC
105
Cov
47%
pass_error
1310.5
_stringify
156.0
__ANON__
20.0
CRAP 311.1
↑ Summary lib/DateTime/Lite/PP.pm »
1 ##----------------------------------------------------------------------------
2 ## Lightweight DateTime Alternative - ~/lib/DateTime/Lite/Duration.pm
3 ## Version v0.1.2
4 ## Copyright(c) 2026 DEGUEST Pte. Ltd.
5 ## Author: Jacques Deguest <jack@deguest.jp>
6 ## Created 2026/04/03
7 ## Modified 2026/05/20
8 ## All rights reserved
9 ##
10 ##
11 ## This program is free software; you can redistribute it and/or modify it
12 ## under the same terms as Perl itself.
13 ##----------------------------------------------------------------------------
14 package DateTime::Lite::Duration;
15 BEGIN
16 17 ▶{
Subroutine BEGIN: called CC=3 SCAR=13.7
17 17 ▶ use v5.10.1;
Subroutine BEGIN: called CC=1 SCAR=0.0
18 17 ▶ use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
19 17 ▶ use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
20 17 ▶ if( $] < 5.013 )
Branch: 1 branch
BranchTrueFalseTotal
if ($] < "5.013") 0 17 17
21 {
22 17 ▶ no strict 'refs';
Subroutine BEGIN: called CC=1 SCAR=0.0
23 0 ▶ unless( defined( &warnings::register_categories ) )
Branch: 1 branch
BranchTrueFalseTotal
unless (defined &warnings::register_categories) 0 0 0
24 {
25 *warnings::_mkMask = sub
26 0 ▶ {
Subroutine __ANON__: not called CC=1 SCAR=6.9
27 0 my $bit = shift( @_ );
28 0 my $mask = "";
29 0 vec( $mask, $bit, 1 ) = 1;
30 0 return( $mask );
31 0 };
32  
33 *warnings::register_categories = sub
34 0 ▶ {
Subroutine __ANON__: not called CC=4 SCAR=30.0
35 0 my @names = @_;
36 0 foreach my $name ( @names )
37 {
38 0 ▶ if( !defined( $warnings::Bits{ $name } ) )
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $warnings::Bits{$name}) 0 0 0
39 {
40 0 $warnings::Offsets{ $name } = $warnings::LAST_BIT;
41 0 $warnings::Bits{ $name } = warnings::_mkMask( $warnings::LAST_BIT++ );
42 0 $warnings::DeadBits{ $name } = warnings::_mkMask( $warnings::LAST_BIT++ );
43 0 ▶ if( length( $warnings::Bits{ $name } ) > length( $warnings::Bits{all} ) )
Branch: 1 branch
BranchTrueFalseTotal
if (length $warnings::Bits{$name} > length $warnings::Bits{"all"}) 0 0 0
44 {
45 0 $warnings::Bits{all} .= "\x55";
46 0 $warnings::DeadBits{all} .= "\xaa";
47 }
48 }
49 }
50 0 };
51 }
52 }
53 17 warnings::register_categories( 'DateTime::Lite' );
54 17 ▶ use vars qw( $VERSION $ERROR );
Subroutine BEGIN: called CC=1 SCAR=0.0
55 17 ▶ use overload (
Subroutine BEGIN: called CC=1 SCAR=0.2
56 '+' => '_add_overload',
57 '-' => '_subtract_overload',
58 '*' => '_multiply_overload',
59 '<=>' => '_compare_overload',
60 'cmp' => '_compare_overload',
61 'neg' => 'inverse',
62 0 ▶ bool => sub{1},
Subroutine __ANON__: not called CC=1 SCAR=6.9
63 17 '""' => \&_stringify,
64 fallback => 1,
65 17 );
66 sub MAX_NANOSECONDS () { 1_000_000_000 }
67 17 ▶ use Scalar::Util ();
Subroutine BEGIN: called CC=1 SCAR=0.0
68 17 ▶ use Wanted;
Subroutine BEGIN: called CC=1 SCAR=0.0
69 17 our $VERSION = 'v0.1.2';
70 };
71  
72 # Keep in unit order from largest to smallest
73 17 my @UNITS = qw( months days minutes seconds nanoseconds );
74 17 my @valid_keys = ( @UNITS, qw( years weeks hours end_of_month ) );
75  
76 # NOTE: Constructor
77 sub new
78 86 ▶{
Subroutine new: called CC=11 SCAR=24.1
Pod documented
79 86 my $this = shift( @_ );
80 86 ▶ my $class = ref( $this ) || $this;
Condition33%1/3
ref $this || $this
l!l&&r!l&&!r
0860
MC/DC0%0/2
ref $this || $this
ref $this $this
Truth table33%1/3
A || B
A= ref $thisB= $this
ABresult
1X1
011
000
81 86 my %p = @_;
82  
83 86 my $self = bless(
84 {
85 months => 0,
86 days => 0,
87 minutes => 0,
88 seconds => 0,
89 nanoseconds => 0,
90 end_of_month => 'wrap',
91 }, $class );
92  
93 86 foreach my $unit ( @UNITS )
94 {
95 430 ▶ $self->{ $unit } = $p{ $unit } // 0;
Condition100%2/2
$p{$unit} // 0
l!l
167263
MC/DC100%1/1
$p{$unit} // 0
$p{$unit}
Truth table100%2/2
A
A= $p{$unit}
Aresult
11
00
96 }
97  
98 86 ▶ if( exists( $p{years} ) )
Branch: 1 branch
BranchTrueFalseTotal
if (exists $p{"years"}) 6 80 86
99 {
100 6 $self->{months} += $p{years} * 12;
101 }
102 86 ▶ if( exists( $p{weeks} ) )
Branch: 1 branch
BranchTrueFalseTotal
if (exists $p{"weeks"}) 2 84 86
103 {
104 2 $self->{days} += $p{weeks} * 7;
105 }
106 86 ▶ if( exists( $p{hours} ) )
Branch: 1 branch
BranchTrueFalseTotal
if (exists $p{"hours"}) 7 79 86
107 {
108 7 $self->{minutes} += $p{hours} * 60;
109 }
110  
111 86 ▶ if( exists( $p{end_of_month} ) )
Branch: 1 branch
BranchTrueFalseTotal
if (exists $p{"end_of_month"}) 2 84 86
112 {
113 2 ▶ unless( $p{end_of_month} =~ /^(?:wrap|limit|preserve)$/ )
Branch: 1 branch
BranchTrueFalseTotal
unless ($p{"end_of_month"} =~ /^(?:wrap|limit|preserve)$/) 0 2 2
114 {
115 0 return( $self->error( "Invalid end_of_month mode '$p{end_of_month}'. Must be 'wrap', 'limit', or 'preserve'." ) );
116 }
117 2 $self->{end_of_month} = $p{end_of_month};
118 }
119  
120 86 delete( @p{ @valid_keys } );
121 86 ▶ if( scalar( keys( %p ) ) )
Branch: 1 branch
BranchTrueFalseTotal
if (scalar keys %p) 2 84 86
122 {
123 2 my @unknown = sort( keys( %p ) );
124 return( $self->error( sprintf(
125 "Unknown argument%s passed to %s->new: %s",
126 scalar( @unknown ) > 1 ? 's' : '',
127 $class,
128 2 ▶ join( ', ', map{ "'$_'" } @unknown ),
Branch: 1 branch
BranchTrueFalseTotal
scalar @unknown > 1 ? : 1 1 2
129 ) ) );
130 }
131  
132 84 $self->_normalise_nanoseconds;
133 84 return( $self );
134 }
135  
136 # NOTE: Accessors (absolute values, matching DateTime::Duration API)
137 1 ▶sub nanoseconds { abs( ( $_[0]->in_units( 'nanoseconds', 'seconds' ) )[0] ) }
Subroutine nanoseconds: called CC=1 SCAR=0.0
Pod documented
138 2 ▶sub seconds { abs( ( $_[0]->in_units( 'seconds', 'minutes' ) )[0] ) }
Subroutine seconds: called CC=1 SCAR=0.0
Pod documented
139 2 ▶sub minutes { abs( ( $_[0]->in_units( 'minutes', 'hours' ) )[0] ) }
Subroutine minutes: called CC=1 SCAR=0.0
Pod documented
140 2 ▶sub hours { abs( $_[0]->in_units( 'hours' ) ) }
Subroutine hours: called CC=1 SCAR=0.0
Pod documented
141 1 ▶sub days { abs( ( $_[0]->in_units( 'days', 'weeks' ) )[0] ) }
Subroutine days: called CC=1 SCAR=0.0
Pod documented
142 1 ▶sub weeks { abs( $_[0]->in_units( 'weeks' ) ) }
Subroutine weeks: called CC=1 SCAR=0.0
Pod documented
143 1 ▶sub months { abs( ( $_[0]->in_units( 'months', 'years' ) )[0] ) }
Subroutine months: called CC=1 SCAR=0.0
Pod documented
144 2 ▶sub years { abs( $_[0]->in_units( 'years' ) ) }
Subroutine years: called CC=1 SCAR=0.0
Pod documented
145  
146 # NOTE: Duration arithmetic
147 sub add
148 0 ▶{
Subroutine add: not called CC=1 SCAR=6.9
Pod documented
149 0 my $self = shift( @_ );
150 0 return( $self->add_duration( $self->_duration_from_args( @_ ) ) );
151 }
152  
153 sub add_duration
154 0 ▶{
Subroutine add_duration: not called CC=4 SCAR=30.0
Pod documented
155 0 my $self = shift( @_ );
156 0 my $dur = shift( @_ );
157  
158 0 ▶ unless( Scalar::Util::blessed( $dur ) && $dur->isa( 'DateTime::Lite::Duration' ) )
Branch: 1 branch
BranchTrueFalseTotal
unless (builtin::blessed($dur) and $dur->isa("DateTime::Lite::Duration")) 0 0 0
Condition0%0/3
builtin::blessed($dur) and $dur->isa("DateTime::Lite::Duration")
!ll&&!rl&&r
000
MC/DC0%0/2
builtin::blessed($dur) and $dur->isa("DateTime::Lite::Duration")
builtin::blessed($dur) $dur->isa("DateTime::Lite::Duration")
Truth table0%0/3
A and B
A= builtin::blessed($dur)B= $dur->isa("DateTime::Lite::Duration")
ABresult
0X0
100
111
159 {
160 0 return( $self->error( "Argument to add_duration() must be a DateTime::Lite::Duration object." ) );
161 }
162  
163 0 foreach my $unit ( @UNITS )
164 {
165 0 $self->{ $unit } += $dur->{ $unit };
166 }
167 0 $self->_normalise_nanoseconds;
168 0 return( $self );
169 }
170  
171 sub calendar_duration
172 1 ▶{
Subroutine calendar_duration: called CC=1 SCAR=0.0
Pod documented
173 1 my $self = shift( @_ );
174 return( ref( $self )->new(
175 months => $self->{months},
176 days => $self->{days},
177 end_of_month => $self->{end_of_month},
178 1 ) );
179 }
180  
181 sub clock_duration
182 1 ▶{
Subroutine clock_duration: called CC=1 SCAR=0.0
Pod documented
183 1 my $self = shift( @_ );
184 return( ref( $self )->new(
185 minutes => $self->{minutes},
186 seconds => $self->{seconds},
187 nanoseconds => $self->{nanoseconds},
188 1 ) );
189 }
190  
191 2 ▶sub clone { bless( { %{ $_[0] } }, ref( $_[0] ) ) }
Subroutine clone: called CC=1 SCAR=0.0
Pod documented
192  
193 # NOTE: Class method: comparison
194 sub compare
195 3 ▶{
Subroutine compare: called CC=4 SCAR=13.9
Pod documented
196 3 ▶ my $class = ref( $_[0] ) ? undef : shift( @_ );
Branch: 1 branch
BranchTrueFalseTotal
ref $_[0] ? : 0 3 3
197 3 my( $d1, $d2 ) = @_;
198  
199 3 foreach my $unit ( @UNITS )
200 {
201 9 my $cmp = $d1->{ $unit } <=> $d2->{ $unit };
202 9 ▶ return( $cmp ) if( $cmp );
Branch: 1 branch
BranchTrueFalseTotal
if $cmp 2 7 9
203 }
204 1 return(0)
205 }
206  
207 # delta_* return the raw (signed) internal values
208  
209 7 ▶sub delta_days { $_[0]->{days} }
Subroutine delta_days: called CC=1 SCAR=0.0
Pod documented
210 5 ▶sub delta_minutes { $_[0]->{minutes} }
Subroutine delta_minutes: called CC=1 SCAR=0.0
Pod documented
211 4 ▶sub delta_months { $_[0]->{months} }
Subroutine delta_months: called CC=1 SCAR=0.0
Pod documented
212 1 ▶sub delta_nanoseconds { $_[0]->{nanoseconds} }
Subroutine delta_nanoseconds: called CC=1 SCAR=0.0
Pod documented
213 3 ▶sub delta_seconds { $_[0]->{seconds} }
Subroutine delta_seconds: called CC=1 SCAR=0.0
Pod documented
214  
215 sub deltas
216 84 ▶{
Subroutine deltas: called CC=1 SCAR=0.0
Pod documented
217 84 my $self = shift( @_ );
218 84 return( map { $_ => $self->{ $_ } } @UNITS );
219 }
220  
221 1 ▶sub end_of_month_mode { return( $_[0]->{end_of_month} ); }
Subroutine end_of_month_mode: called CC=1 SCAR=0.0
Pod documented
222  
223 # Error handling: same pattern as Locale::Unicode / Module::Generic
224 sub error
225 5 ▶{
Subroutine error: called CC=8 SCAR=22.1
Pod documented
226 5 my $self = shift( @_ );
227 5 ▶ if( @_ )
Branch: 1 branch
BranchTrueFalseTotal
if (@_) 2 3 5
228 {
229 2 require DateTime::Lite::Exception;
230 2 ▶ my $msg = join( '', map( ( ref( $_ ) eq 'CODE' ) ? $_->() : $_, @_ ) );
Branch: 1 branch
BranchTrueFalseTotal
ref $_ eq 'CODE' ? : 0 2 2
231 2 my $e = DateTime::Lite::Exception->new({
232 skip_frames => 1,
233 message => $msg,
234 });
235 2 $ERROR = $e;
236 2 ▶ $self->{error} = $e if( ref( $self ) );
Branch: 1 branch
BranchTrueFalseTotal
if ref $self 2 0 2
237 2 ▶ if( $self->fatal )
Branch: 1 branch
BranchTrueFalseTotal
if ($self->fatal) { } 0 2 2
238 {
239 0 die( $self->{error} );
240 }
241 else
242 {
243 2 ▶ warn( $msg ) if( warnings::enabled( 'DateTime::Lite' ) );
Branch: 1 branch
BranchTrueFalseTotal
if warnings::enabled("DateTime::Lite") 2 0 2
244 2 ▶ rreturn( DateTime::Lite::NullObject->new ) if( want( 'OBJECT' ) );
Branch: 1 branch
BranchTrueFalseTotal
if want("OBJECT") 0 2 2
245 2 return;
246 }
247 }
248 3 ▶ return( ref( $self ) ? $self->{error} : $ERROR );
Branch: 1 branch
BranchTrueFalseTotal
ref $self ? : 0 3 3
249 }
250  
251 2 ▶sub fatal { return( shift->_set_get_prop( 'fatal', @_ ) ); }
Subroutine fatal: called CC=1 SCAR=0.0
Pod documented
252  
253 # NOTE: in_units / deltas
254 sub in_units
255 19 ▶{
Subroutine in_units: called CC=5 SCAR=16.1
Pod documented
256 19 my $self = shift( @_ );
257 19 my @units = @_;
258  
259 # Maps a "virtual" large unit to the stored base unit and its divisor:
260 # years -> months / 12
261 # weeks -> days / 7
262 # hours -> minutes / 60
263 19 my %large_unit = (
264 years => [ months => 12 ],
265 weeks => [ days => 7 ],
266 hours => [ minutes => 60 ],
267 );
268  
269 # Working copy of the five stored buckets.
270 19 my %remaining = map { $_ => $self->{ $_ } } @UNITS;
271 19 my %result;
272  
273 # Large units (years/weeks/hours) must be processed before their
274 # corresponding stored units (months/days/minutes), regardless of
275 # the caller's ordering, otherwise the remainder calculation is wrong.
276 my @ordered = (
277 29 ( grep { exists( $large_unit{ $_ } ) } @units ),
278 19 ( grep { !exists( $large_unit{ $_ } ) } @units ),
279 );
280  
281 19 foreach my $unit ( @ordered )
282 {
283 29 ▶ if( exists( $large_unit{ $unit } ) )
Branch: 1 branch
BranchTrueFalseTotal
if (exists $large_unit{$unit}) { } 12 17 29
284 {
285 12 my( $base, $divisor ) = @{ $large_unit{ $unit } };
286 17 ▶ use integer;
Subroutine BEGIN: called CC=1 SCAR=0.0
287 12 $result{ $unit } = $remaining{ $base } / $divisor;
288 12 $remaining{ $base } -= $result{ $unit } * $divisor;
289 }
290 else
291 {
292 # Stored unit: return whatever remains in its bucket.
293 17 ▶ $result{ $unit } = $remaining{ $unit } // 0;
Condition50%1/2
$remaining{$unit} // 0
l!l
170
MC/DC0%0/1
$remaining{$unit} // 0
$remaining{$unit}
Truth table50%1/2
A
A= $remaining{$unit}
Aresult
11
00
294 }
295 }
296  
297 19 ▶ return( @units == 1 ? $result{ $units[0] } : @result{ @units } );
Branch: 1 branch
BranchTrueFalseTotal
@units == 1 ? : 9 10 19
298 }
299  
300 sub inverse
301 16 ▶{
Subroutine inverse: called CC=2 SCAR=7.1
Pod documented
302 16 my $self = shift( @_ );
303 16 my %eom = @_;
304  
305 my $new = ref( $self )->new(
306 16 map { $_ => -1 * $self->{ $_ } } @UNITS
307 );
308  
309 16 ▶ $new->{end_of_month} = $eom{end_of_month} // $self->{end_of_month};
Condition33%1/3
$eom{"end_of_month"} // $self->{"end_of_month"}
l!l&&r!l&&!r
0160
MC/DC0%0/2
$eom{"end_of_month"} // $self->{"end_of_month"}
$eom{"end_of_month"} $self->{"end_of_month"}
Truth table33%1/3
A // B
A= $eom{"end_of_month"}B= $self->{"end_of_month"}
ABresult
1X1
011
000
310  
311 16 return( $new );
312 }
313  
314 1 ▶sub is_limit_mode { $_[0]->{end_of_month} eq 'limit' ? 1 : 0 }
Subroutine is_limit_mode: called CC=2 SCAR=7.6
Pod documented
Branch: 1 branch
BranchTrueFalseTotal
$_[0]{'end_of_month'} eq 'limit' ? : 1 0 1
315 2 ▶sub is_negative { !$_[0]->_has_positive && $_[0]->_has_negative }
Subroutine is_negative: called CC=2 SCAR=6.9
Pod documented
Branch: 1 branch
BranchTrueFalseTotal
not $_[0]->_has_positive and $_[0]->_has_negative 1 1 2
316 2 ▶sub is_positive { $_[0]->_has_positive && !$_[0]->_has_negative }
Subroutine is_positive: called CC=2 SCAR=6.9
Pod documented
Branch: 1 branch
BranchTrueFalseTotal
$_[0]->_has_positive and not $_[0]->_has_negative 1 1 2
317 23 ▶sub is_preserve_mode { $_[0]->{end_of_month} eq 'preserve' ? 1 : 0 }
Subroutine is_preserve_mode: called CC=2 SCAR=7.6
Pod documented
Branch: 1 branch
BranchTrueFalseTotal
$_[0]{'end_of_month'} eq 'preserve' ? : 0 23 23
318 12 ▶sub is_wrap_mode { $_[0]->{end_of_month} eq 'wrap' ? 1 : 0 }
Subroutine is_wrap_mode: called CC=2 SCAR=6.9
Pod documented
Branch: 1 branch
BranchTrueFalseTotal
$_[0]{'end_of_month'} eq 'wrap' ? : 11 1 12
319  
320 sub is_zero
321 44 ▶{
Subroutine is_zero: called CC=3 SCAR=11.0
Pod documented
322 44 my $self = shift( @_ );
323 44 foreach my $unit ( @UNITS )
324 {
325 128 ▶ return(0) if( $self->{ $unit } != 0 );
Branch: 1 branch
BranchTrueFalseTotal
if $self->{$unit} != 0 43 85 128
326 }
327 1 return(1)
328 }
329  
330 sub pass_error
331 0 ▶{
Subroutine pass_error: not called CC=37 SCAR=71.8
Pod documented
332 0 my $self = shift( @_ );
333 0 ▶ my $pack = ref( $self ) || $self;
Condition0%0/3
ref $self || $self
l!l&&r!l&&!r
000
MC/DC0%0/2
ref $self || $self
ref $self $self
Truth table0%0/3
A || B
A= ref $selfB= $self
ABresult
1X1
011
000
334 0 my $opts = {};
335 0 my( $err, $class, $code );
336 17 ▶ no strict 'refs';
Subroutine BEGIN: called CC=1 SCAR=0.0
337 0 ▶ if( scalar( @_ ) )
Branch: 1 branch
BranchTrueFalseTotal
if (scalar @_) 0 0 0
338 {
339 # Either an hash defining a new error and this will be passed along to error(); or
340 # an hash with a single property: { class => 'Some::ExceptionClass' }
341 0 ▶ if( scalar( @_ ) == 1 && ref( $_[0] ) eq 'HASH' )
Branch: 1 branch
BranchTrueFalseTotal
if (scalar @_ == 1 and ref $_[0] eq 'HASH') { } 0 0 0
Condition0%0/3
scalar @_ == 1 and ref $_[0] eq "HASH"
!ll&&!rl&&r
000
MC/DC0%0/2
scalar @_ == 1 and ref $_[0] eq "HASH"
scalar @_ == 1 ref $_[0] eq "HASH"
Truth table0%0/3
A and B
A= scalar @_ == 1B= ref $_[0] eq "HASH"
ABresult
0X0
100
111
342 {
343 0 $opts = $_[0];
344 }
345 else
346 {
347 0 ▶ if( scalar( @_ ) > 1 && ref( $_[-1] ) eq 'HASH' )
Branch: 1 branch
BranchTrueFalseTotal
if (scalar @_ > 1 and ref $_[-1] eq "HASH") 0 0 0
Condition0%0/3
scalar @_ > 1 and ref $_[-1] eq "HASH"
!ll&&!rl&&r
000
MC/DC0%0/2
scalar @_ > 1 and ref $_[-1] eq "HASH"
scalar @_ > 1 ref $_[-1] eq "HASH"
Truth table0%0/3
A and B
A= scalar @_ > 1B= ref $_[-1] eq "HASH"
ABresult
0X0
100
111
348 {
349 0 $opts = pop( @_ );
350 }
351 0 $err = $_[0];
352 }
353 }
354 0 ▶ $err = $opts->{error} if( !defined( $err ) && CORE::exists( $opts->{error} ) && defined( $opts->{error} ) && CORE::length( $opts->{error} ) );
Branch: 1 branch
BranchTrueFalseTotal
if not defined $err and exists $opts->{"error"} and defined $opts->{"error"} and length $opts->{"error"} 0 0 0
Condition0%0/9
not defined $err and exists $opts->{"error"} and defined $opts->{"error"} and length $opts->{"error"}
!ll&&!rl&&r
000
not defined $err and exists $opts->{"error"} and defined $opts->{"error"}
!ll&&!rl&&r
000
not defined $err and exists $opts->{"error"}
!ll&&!rl&&r
000
MC/DC0%0/4
not defined $err and exists $opts->{"error"} and defined $opts->{"error"} and length $opts->{"error"}
not defined $err exists $opts->{"error"} defined $opts->{"error"} length $opts->{"error"}
Truth table0%0/5
not(A) and B and C and D
A= not defined $errB= exists $opts->{"error"}C= defined $opts->{"error"}D= length $opts->{"error"}
ABCDresult
0XXX0
10XX0
110X0
11100
11111
355 # We set $class only if the hash provided is a one-element hash and not an error-defining hash
356 0 ▶ $class = $opts->{class} if( CORE::exists( $opts->{class} ) && defined( $opts->{class} ) && CORE::length( $opts->{class} ) );
Branch: 1 branch
BranchTrueFalseTotal
if exists $opts->{"class"} and defined $opts->{"class"} and length $opts->{"class"} 0 0 0
Condition0%0/6
exists $opts->{"class"} and defined $opts->{"class"} and length $opts->{"class"}
!ll&&!rl&&r
000
exists $opts->{"class"} and defined $opts->{"class"}
!ll&&!rl&&r
000
MC/DC0%0/3
exists $opts->{"class"} and defined $opts->{"class"} and length $opts->{"class"}
exists $opts->{"class"} defined $opts->{"class"} length $opts->{"class"}
Truth table0%0/4
A and B and C
A= exists $opts->{"class"}B= defined $opts->{"class"}C= length $opts->{"class"}
ABCresult
0XX0
10X0
1100
1111
357 0 ▶ $code = $opts->{code} if( CORE::exists( $opts->{code} ) && defined( $opts->{code} ) && CORE::length( $opts->{code} ) );
Branch: 1 branch
BranchTrueFalseTotal
if exists $opts->{"code"} and defined $opts->{"code"} and length $opts->{"code"} 0 0 0
Condition0%0/6
exists $opts->{"code"} and defined $opts->{"code"} and length $opts->{"code"}
!ll&&!rl&&r
000
exists $opts->{"code"} and defined $opts->{"code"}
!ll&&!rl&&r
000
MC/DC0%0/3
exists $opts->{"code"} and defined $opts->{"code"} and length $opts->{"code"}
exists $opts->{"code"} defined $opts->{"code"} length $opts->{"code"}
Truth table0%0/4
A and B and C
A= exists $opts->{"code"}B= defined $opts->{"code"}C= length $opts->{"code"}
ABCresult
0XX0
10X0
1100
1111
358  
359 # called with no argument, most likely from the same class to pass on an error
360 # set up earlier by another method; or
361 # with an hash containing just one argument class => 'Some::ExceptionClass'
362 0 ▶ if( !defined( $err ) && ( !scalar( @_ ) || defined( $class ) ) )
Branch: 2 branches
BranchTrueFalseTotal
if (not defined $err and !scalar(@_) || defined $class) { } 0 0 0
elsif (defined $err and builtin::blessed($err) and scalar @_ == 1 || scalar @_ == 2 && defined $class) { } 0 0 0
Condition0%0/6
not defined $err and !scalar(@_) || defined $class
!ll&&!rl&&r
000
not scalar @_ or defined $class
l!l&&r!l&&!r
000
MC/DC0%0/3
not defined $err and !scalar(@_) || defined $class
not defined $err not scalar @_ defined $class
Truth table0%0/4
not(A) and not(B) or C
A= not defined $errB= not scalar @_C= defined $class
ABCresult
0XX0
1000
11X1
1011
363 {
364 # $error is a previous erro robject
365 0 ▶ my $error = ref( $self ) ? $self->{error} : length( ${ $pack . '::ERROR' } ) ? ${ $pack . '::ERROR' } : undef;
Branch: 2 branches
BranchTrueFalseTotal
ref $self ? : 0 0 0
length ${$pack . '::ERROR';} ? : 0 0 0
366 0 ▶ if( !defined( $error ) )
Branch: 1 branch
BranchTrueFalseTotal
if (not defined $error) { } 0 0 0
367 {
368 0 warn( "No error object provided and no previous error set either! It seems the previous method call returned a simple undef" );
369 }
370 else
371 {
372 0 ▶ $err = ( defined( $class ) ? bless( $error => $class ) : $error );
Branch: 1 branch
BranchTrueFalseTotal
defined $class ? : 0 0 0
373 0 ▶ $err->code( $code ) if( defined( $code ) );
Branch: 1 branch
BranchTrueFalseTotal
if defined $code 0 0 0
374 }
375 }
376 ▶ elsif( defined( $err ) &&
Condition0%0/12
defined $err and builtin::blessed($err) and scalar @_ == 1 || scalar @_ == 2 && defined $class
!ll&&!rl&&r
000
defined $err and builtin::blessed($err)
!ll&&!rl&&r
000
scalar @_ == 1 or scalar @_ == 2 and defined $class
l!l&&r!l&&!r
000
scalar @_ == 2 and defined $class
!ll&&!rl&&r
000
MC/DC0%0/5
defined $err and builtin::blessed($err) and scalar @_ == 1 || scalar @_ == 2 && defined $class
defined $err builtin::blessed($err) scalar @_ == 1 scalar @_ == 2 defined $class
Truth table0%0/6
A and B and C or D and E
A= defined $errB= builtin::blessed($err)C= scalar @_ == 1D= scalar @_ == 2E= defined $class
ABCDEresult
0XXXX0
10XXX0
1100X0
110100
111XX1
110111
377 Scalar::Util::blessed( $err ) &&
378 ( scalar( @_ ) == 1 ||
379 ( scalar( @_ ) == 2 && defined( $class ) )
380 ) )
381 {
382 0 ▶ $self->{error} = ${ $pack . '::ERROR' } = ( defined( $class ) ? bless( $err => $class ) : $err );
Branch: 1 branch
BranchTrueFalseTotal
defined $class ? : 0 0 0
383 0 ▶ $self->{error}->code( $code ) if( defined( $code ) && $self->{error}->can( 'code' ) );
Branch: 1 branch
BranchTrueFalseTotal
if defined $code and $self->{"error"}->can("code") 0 0 0
Condition0%0/3
defined $code and $self->{"error"}->can("code")
!ll&&!rl&&r
000
MC/DC0%0/2
defined $code and $self->{"error"}->can("code")
defined $code $self->{"error"}->can("code")
Truth table0%0/3
A and B
A= defined $codeB= $self->{"error"}->can("code")
ABresult
0X0
100
111
384  
385 0 ▶ if( $self->{fatal} || ( defined( ${"${pack}\::FATAL_EXCEPTIONS"} ) && ${"${pack}\::FATAL_EXCEPTIONS"} ) )
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{"fatal"} or defined ${"${pack}::FATAL_EXCEPTIONS";} and ${"${pack}::FATAL_EXCEPTIONS";}) 0 0 0
Condition0%0/6
$self->{"fatal"} or defined ${"${pack}::FATAL_EXCEPTIONS";} and ${"${pack}::FATAL_EXCEPTIONS";}
l!l&&r!l&&!r
000
defined ${"${pack}::FATAL_EXCEPTIONS";} and ${"${pack}::FATAL_EXCEPTIONS";}
!ll&&!rl&&r
000
MC/DC0%0/3
$self->{"fatal"} or defined ${"${pack}::FATAL_EXCEPTIONS";} and ${"${pack}::FATAL_EXCEPTIONS";}
$self->{"fatal"} defined ${"${pack}::FATAL_EXCEPTIONS";} ${"${pack}::FATAL_EXCEPTIONS";}
Truth table0%0/4
A or B and C
A= $self->{"fatal"}B= defined ${"${pack}::FATAL_EXCEPTIONS";}C= ${"${pack}::FATAL_EXCEPTIONS";}
ABCresult
1XX1
0111
00X0
0100
386 {
387 0 die( $self->{error} );
388 }
389 }
390 # If the error provided is not an object, we call error to create one
391 else
392 {
393 0 return( $self->error( @_ ) );
394 }
395  
396 0 ▶ if( want( 'OBJECT' ) )
Branch: 1 branch
BranchTrueFalseTotal
if (want("OBJECT")) 0 0 0
397 {
398 0 rreturn( DateTime::Lite::NullObject->new );
399 }
400 0 return;
401 }
402  
403 sub subtract
404 0 ▶{
Subroutine subtract: not called CC=1 SCAR=6.9
Pod documented
405 0 my $self = shift( @_ );
406 0 return( $self->add_duration( $self->_duration_from_args( @_ )->inverse ) );
407 }
408  
409 0 ▶sub subtract_duration { return( $_[0]->add_duration( $_[1]->inverse ) ) }
Subroutine subtract_duration: not called CC=1 SCAR=6.9
Pod documented
410  
411 # NOTE: Sign predicates
412 sub _has_negative
413 2 ▶{
Subroutine _has_negative: called CC=3 SCAR=11.0
414 2 my $self = shift( @_ );
415 2 foreach my $unit ( @UNITS )
416 {
417 7 ▶ return(1) if( $self->{ $unit } < 0 );
Branch: 1 branch
BranchTrueFalseTotal
if $self->{$unit} < 0 1 6 7
418 }
419 1 return(0)
420 }
421  
422 sub _has_positive
423 4 ▶{
Subroutine _has_positive: called CC=3 SCAR=11.0
424 4 my $self = shift( @_ );
425 4 foreach my $unit ( @UNITS )
426 {
427 14 ▶ return(1) if( $self->{ $unit } > 0 );
Branch: 1 branch
BranchTrueFalseTotal
if $self->{$unit} > 0 2 12 14
428 }
429 2 return(0)
430 }
431  
432 # NOTE: Overloaded operators
433 sub _add_overload
434 0 ▶{
Subroutine _add_overload: not called CC=2 SCAR=17.9
435 0 my( $self, $other, $reversed ) = @_;
436 0 ▶ ( $self, $other ) = ( $other, $self ) if( $reversed );
Branch: 1 branch
BranchTrueFalseTotal
if $reversed 0 0 0
437 0 return( $self->clone->add_duration( $other ) );
438 }
439  
440 sub _compare_overload
441 0 ▶{
Subroutine _compare_overload: not called CC=2 SCAR=17.9
442 0 my( $d1, $d2, $flip ) = @_;
443 0 my $result = DateTime::Lite::Duration->compare( $d1, $d2 );
444 0 ▶ return( $flip ? -$result : $result );
Branch: 1 branch
BranchTrueFalseTotal
$flip ? : 0 0 0
445 }
446  
447 # NOTE: Private helpers
448 sub _duration_from_args
449 0 ▶{
Subroutine _duration_from_args: not called CC=4 SCAR=30.0
450 0 my $self = shift( @_ );
451 0 ▶ return( $_[0] )
Branch: 1 branch
BranchTrueFalseTotal
if @_ == 1 and builtin::blessed($_[0]) and $_[0]->isa(ref $self) 0 0 0
Condition0%0/6
@_ == 1 and builtin::blessed($_[0]) and $_[0]->isa(ref $self)
!ll&&!rl&&r
000
@_ == 1 and builtin::blessed($_[0])
!ll&&!rl&&r
000
MC/DC0%0/3
@_ == 1 and builtin::blessed($_[0]) and $_[0]->isa(ref $self)
@_ == 1 builtin::blessed($_[0]) $_[0]->isa(ref $self)
Truth table0%0/4
A and B and C
A= @_ == 1B= builtin::blessed($_[0])C= $_[0]->isa(ref $self)
ABCresult
0XX0
10X0
1100
1111
452 if( @_ == 1 && Scalar::Util::blessed( $_[0] ) && $_[0]->isa( ref( $self ) ) );
453 0 return( ref( $self )->new( @_ ) );
454 }
455  
456 sub _multiply_overload
457 1 ▶{
Subroutine _multiply_overload: called CC=2 SCAR=6.9
458 1 my( $self, $factor ) = @_;
459 1 my $new = $self->clone;
460 1 foreach my $unit ( @UNITS )
461 {
462 5 $new->{ $unit } = int( $new->{ $unit } * $factor );
463 }
464 1 $new->_normalise_nanoseconds;
465 1 return( $new );
466 }
467  
468 sub _normalise_nanoseconds
469 85 ▶{
Subroutine _normalise_nanoseconds: called CC=5 SCAR=16.1
470 85 my $self = shift( @_ );
471 85 my $ns = $self->{nanoseconds};
472 85 ▶ return if( $ns >= 0 && $ns < MAX_NANOSECONDS );
Branch: 1 branch
BranchTrueFalseTotal
if $ns >= 0 and $ns < 1000000000 72 13 85
Condition100%3/3
$ns >= 0 and $ns < 1000000000
!ll&&!rl&&r
12172
MC/DC100%2/2
$ns >= 0 and $ns < 1000000000
$ns >= 0 $ns < 1000000000
Truth table100%3/3
A and B
A= $ns >= 0B= $ns < 1000000000
ABresult
0X0
100
111
473  
474 17 ▶ use integer;
Subroutine BEGIN: called CC=1 SCAR=0.0
475 13 ▶ if( $ns < 0 )
Branch: 2 branches
BranchTrueFalseTotal
if ($ns < 0) { } 12 1 13
elsif ($ns >= 1000000000) { } 1 0 1
476 {
477 12 my $overflow = 1 + ( -$ns - 1 ) / MAX_NANOSECONDS;
478 12 $self->{nanoseconds} += $overflow * MAX_NANOSECONDS;
479 12 $self->{seconds} -= $overflow;
480 }
481 elsif( $ns >= MAX_NANOSECONDS )
482 {
483 1 my $overflow = $ns / MAX_NANOSECONDS;
484 1 $self->{nanoseconds} -= $overflow * MAX_NANOSECONDS;
485 1 $self->{seconds} += $overflow;
486 }
487 }
488  
489 sub _set_get_prop
490 2 ▶{
Subroutine _set_get_prop: called CC=3 SCAR=11.4
491 2 my $self = shift( @_ );
492 2 ▶ my $prop = shift( @_ ) || die( "No object property was provided." );
Condition50%1/2
shift @_ || die('No object property was provided.')
l!l
20
MC/DC0%0/1
shift @_ || die('No object property was provided.')
shift @_
Truth table50%1/2
A
A= shift @_
Aresult
11
00
493 2 ▶ $self->{ $prop } = shift( @_ ) if( @_ );
Branch: 1 branch
BranchTrueFalseTotal
if @_ 0 2 2
494 2 return( $self->{ $prop } );
495 }
496  
497 sub _stringify
498 0 ▶{
Subroutine _stringify: not called CC=12 SCAR=50.5
499 0 my $self = shift( @_ );
500 # P[n]Y[n]M[n]DT[n]H[n]M[n]S ISO 8601 duration
501 0 my $str = 'P';
502 0 my( $y, $mo ) = $self->in_units( 'years', 'months' );
503 0 my( $w, $d ) = $self->in_units( 'weeks', 'days' );
504 0 my( $h, $mi ) = $self->in_units( 'hours', 'minutes' );
505 0 my $s = $self->{seconds};
506 0 ▶ $str .= "${y}Y" if( $y );
Branch: 1 branch
BranchTrueFalseTotal
if $y 0 0 0
507 0 ▶ $str .= "${mo}M" if( $mo );
Branch: 1 branch
BranchTrueFalseTotal
if $mo 0 0 0
508 0 ▶ $str .= "${w}W" if( $w );
Branch: 1 branch
BranchTrueFalseTotal
if $w 0 0 0
509 0 ▶ $str .= "${d}D" if( $d );
Branch: 1 branch
BranchTrueFalseTotal
if $d 0 0 0
510 0 ▶ if( $h || $mi || $s )
Branch: 1 branch
BranchTrueFalseTotal
if ($h or $mi or $s) 0 0 0
Condition0%0/6
$h or $mi or $s
l!l&&r!l&&!r
000
$h or $mi
l!l&&r!l&&!r
000
MC/DC0%0/3
$h or $mi or $s
$h $mi $s
Truth table0%0/4
A or B or C
A= $hB= $miC= $s
ABCresult
1XX1
01X1
0011
0000
511 {
512 0 $str .= 'T';
513 0 ▶ $str .= "${h}H" if( $h );
Branch: 1 branch
BranchTrueFalseTotal
if $h 0 0 0
514 0 ▶ $str .= "${mi}M" if( $mi );
Branch: 1 branch
BranchTrueFalseTotal
if $mi 0 0 0
515 0 ▶ $str .= "${s}S" if( $s );
Branch: 1 branch
BranchTrueFalseTotal
if $s 0 0 0
516 }
517 0 ▶ return( $str || 'P0D' );
Condition0%0/2
$str || 'P0D'
l!l
00
MC/DC0%0/1
$str || 'P0D'
$str
Truth table0%0/2
A
A= $str
Aresult
11
00
518 }
519  
520 sub _subtract_overload
521 0 ▶{
Subroutine _subtract_overload: not called CC=2 SCAR=17.9
522 0 my( $d1, $d2, $flip ) = @_;
523 0 ▶ ( $d1, $d2 ) = ( $d2, $d1 ) if( $flip );
Branch: 1 branch
BranchTrueFalseTotal
if $flip 0 0 0
524 0 return( $d1->clone->subtract_duration( $d2 ) );
525 }
526  
527 17 1;
528 # NOTE: POD
529 __END__
↑ Summary lib/DateTime/Lite/PP.pm »