blib/lib/DateTime.pm

filter: Statementstmt 98.9% 848 / 857 Branchbran 92.6% 326 / 352 Conditioncond 85.9% 135 / 157 MC/DCmcdc 76.6% 72 / 94 Subroutinesub 99.6% 258 / 259 Podpod 89.5% 103 / 115 totaltotal 94.9% 1742 / 1834 CC 234 SCAR 16.4
CC
234
Cov
96%
subtract_datetime
20.1
_handle_offset_modifier
19.0
_compare
17.0
CRAP 5.2
« blib/lib/DateTime/PPExtra.pm ↑ Summary blib/lib/DateTime/Duration.pm »
1 ## no critic (Modules::ProhibitExcessMainComplexity)
2 package DateTime;
3  
4 49 ▶use 5.008004;
Subroutine BEGIN: called CC=1 SCAR=0.0
5  
6 49 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
7 49 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
8 49 ▶use warnings::register;
Subroutine BEGIN: called CC=1 SCAR=0.0
9 49 ▶use namespace::autoclean 0.19;
Subroutine BEGIN: called CC=1 SCAR=0.0
10  
11 49 our $VERSION = '1.68';
12  
13 49 ▶use Carp;
Subroutine BEGIN: called CC=1 SCAR=0.0
14 49 ▶use DateTime::Duration;
Subroutine BEGIN: called CC=1 SCAR=0.0
15 49 ▶use DateTime::Helpers;
Subroutine BEGIN: called CC=1 SCAR=0.0
16 49 ▶use DateTime::Locale 1.47;
Subroutine BEGIN: called CC=1 SCAR=0.0
17 49 ▶use DateTime::TimeZone 2.44;
Subroutine BEGIN: called CC=1 SCAR=0.0
18 49 ▶use DateTime::Types;
Subroutine BEGIN: called CC=1 SCAR=0.0
19 49 ▶use POSIX qw( floor fmod );
Subroutine BEGIN: called CC=1 SCAR=0.0
20 49 ▶use Params::ValidationCompiler 0.26 qw( validation_for );
Subroutine BEGIN: called CC=1 SCAR=0.0
21 49 ▶use Scalar::Util qw( blessed );
Subroutine BEGIN: called CC=1 SCAR=0.0
22 49 ▶use Specio::Subs qw( Specio::Library::Builtins );
Subroutine BEGIN: called CC=1 SCAR=0.0
23 49 ▶use Try::Tiny;
Subroutine BEGIN: called CC=1 SCAR=0.0
24  
25 ## no critic (Variables::ProhibitPackageVars)
26 49 our $IsPurePerl;
27  
28 {
29 49 my $loaded = 0;
30  
31 49 ▶ unless ( $ENV{PERL_DATETIME_PP} ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($ENV{"PERL_DATETIME_PP"}) 49 0 49
32 49 ▶ try {
Subroutine __ANON__: called CC=3 SCAR=11.6
33 49 require XSLoader;
34 XSLoader::load(
35 __PACKAGE__,
36 49 exists $DateTime::{VERSION} && ${ $DateTime::{VERSION} }
37 49 ▶ ? ${ $DateTime::{VERSION} }
Branch: 1 branch
BranchTrueFalseTotal
exists $main::DateTime::{'VERSION'} && ${$main::DateTime::{'VERSION'};} ? : 49 0 49
Condition33%1/3
exists $main::DateTime::{"VERSION"} and ${$main::DateTime::{"VERSION"};}
!ll&&!rl&&r
0049
MC/DC0%0/2
exists $main::DateTime::{"VERSION"} and ${$main::DateTime::{"VERSION"};}
exists $main::DateTime::{"VERSION"} ${$main::DateTime::{"VERSION"};}
Truth table33%1/3
A and B
A= exists $main::DateTime::{"VERSION"}B= ${$main::DateTime::{"VERSION"};}
ABresult
0X0
100
111
38 : 42
39 );
40  
41 48 $loaded = 1;
42 48 $IsPurePerl = 0;
43 }
44 1 ▶ catch {
Subroutine __ANON__: called CC=3 SCAR=14.2
45 1 ▶ die $_ if $_ && $_ !~ /object version|loadable object/;
Branch: 1 branch
BranchTrueFalseTotal
if $_ and not $_ =~ /object version|loadable object/ 0 1 1
Condition33%1/3
$_ and not $_ =~ /object version|loadable object/
!ll&&!rl&&r
010
MC/DC0%0/2
$_ and not $_ =~ /object version|loadable object/
$_ not $_ =~ /object version|loadable object/
Truth table33%1/3
A and not(B)
A= $_B= not $_ =~ /object version|loadable object/
ABresult
0X0
100
111
46 49 };
47 }
48  
49 49 ▶ if ($loaded) {
Branch: 1 branch
BranchTrueFalseTotal
if ($loaded) { } 48 1 49
50 ## no critic (Variables::ProtectPrivateVars)
51 require DateTime::PPExtra
52 48 ▶ unless defined &DateTime::_normalize_tai_seconds;
Branch: 1 branch
BranchTrueFalseTotal
unless defined &DateTime::_normalize_tai_seconds 0 48 48
53 }
54 else {
55 1 require DateTime::PP;
56 }
57 }
58  
59 # for some reason, overloading doesn't work unless fallback is listed
60 # early.
61 #
62 # 3rd parameter ( $_[2] ) means the parameters are 'reversed'.
63 # see: "Calling conventions for binary operations" in overload docs.
64 #
65 49 ▶use overload (
Subroutine BEGIN: called CC=1 SCAR=0.0
66 fallback => 1,
67 '<=>' => '_compare_overload',
68 'cmp' => '_string_compare_overload',
69 q{""} => 'stringify',
70 22 ▶ bool => sub {1},
Subroutine __ANON__: called CC=1 SCAR=0.0
71 49 '-' => '_subtract_overload',
72 '+' => '_add_overload',
73 'eq' => '_string_equals_overload',
74 'ne' => '_string_not_equals_overload',
75 49 );
76  
77 # Have to load this after overloading is defined, after BEGIN blocks
78 # or else weird crashes ensue
79 49 require DateTime::Infinite;
80  
81 sub MAX_NANOSECONDS () {1_000_000_000} # 1E9 = almost 32 bits
82 sub INFINITY () { 100**100**100**100 }
83 sub NEG_INFINITY () { -1 * ( 100**100**100**100 ) }
84 sub NAN () { INFINITY - INFINITY }
85  
86 sub SECONDS_PER_DAY () {86400}
87  
88 sub duration_class () {'DateTime::Duration'}
89  
90 my (
91 49 @MonthLengths,
92 @LeapYearMonthLengths,
93 @QuarterLengths,
94 @LeapYearQuarterLengths,
95 );
96  
97 49 ▶BEGIN {
Subroutine BEGIN: called CC=1 SCAR=0.0
98 49 @MonthLengths = ( 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 );
99  
100 49 @LeapYearMonthLengths = @MonthLengths;
101 49 $LeapYearMonthLengths[1]++;
102  
103 49 @QuarterLengths = ( 90, 91, 92, 92 );
104  
105 49 @LeapYearQuarterLengths = @QuarterLengths;
106 49 $LeapYearQuarterLengths[0]++;
107 }
108  
109 {
110  
111 # I'd rather use Class::Data::Inheritable for this, but there's no
112 # way to add the module-loading behavior to an accessor it
113 # creates, despite what its docs say!
114 49 my $DefaultLocale;
115  
116 25446 ▶ sub DefaultLocale {
Subroutine DefaultLocale: called CC=2 SCAR=6.9
Pod documented
117 25446 shift;
118  
119 25446 ▶ if (@_) {
Branch: 1 branch
BranchTrueFalseTotal
if (@_) 50 25396 25446
120 50 my $lang = shift;
121  
122 50 $DefaultLocale = DateTime::Locale->load($lang);
123 }
124  
125 25446 return $DefaultLocale;
126 }
127 }
128 49 __PACKAGE__->DefaultLocale('en-US');
129  
130 {
131 49 my $validator = validation_for(
132 name => '_check_new_params',
133 name_is_optional => 1,
134 params => {
135 year => { type => t('Year') },
136 month => {
137 type => t('Month'),
138 default => 1,
139 },
140 day => {
141 type => t('DayOfMonth'),
142 default => 1,
143 },
144 hour => {
145 type => t('Hour'),
146 default => 0,
147 },
148 minute => {
149 type => t('Minute'),
150 default => 0,
151 },
152 second => {
153 type => t('Second'),
154 default => 0,
155 },
156 nanosecond => {
157 type => t('Nanosecond'),
158 default => 0,
159 },
160 locale => {
161 type => t('Locale'),
162 optional => 1,
163 },
164 formatter => {
165 type => t('Formatter'),
166 optional => 1,
167 },
168 time_zone => {
169 type => t('TimeZone'),
170 optional => 1,
171 },
172 },
173 );
174  
175 48758 ▶ sub new {
Subroutine new: called CC=3 SCAR=11.0
Pod documented
176 48758 my $class = shift;
177 48758 my %p = $validator->(@_);
178  
179 Carp::croak(
180 "Invalid day of month (day = $p{day} - month = $p{month} - year = $p{year})\n"
181 )
182 if $p{day} > 28
183 48740 ▶ && $p{day} > $class->_month_length( $p{year}, $p{month} );
Branch: 1 branch
BranchTrueFalseTotal
if $p{"day"} > 28 and $p{"day"} > $class->_month_length($p{"year"}, $p{"month"}) 2 48738 48740
Condition100%3/3
$p{"day"} > 28 and $p{"day"} > $class->_month_length($p{"year"}, $p{"month"})
!ll&&!rl&&r
23388253502
MC/DC100%2/2
$p{"day"} > 28 and $p{"day"} > $class->_month_length($p{"year"}, $p{"month"})
$p{"day"} > 28 $p{"day"} > $class->_month_length($p{"year"}, $p{"month"})
Truth table100%3/3
A and B
A= $p{"day"} > 28B= $p{"day"} > $class->_month_length($p{"year"}, $p{"month"})
ABresult
0X0
100
111
184  
185 48738 return $class->_new(%p);
186 }
187 }
188  
189 49 ▶sub _new {
Subroutine _new: called CC=13 SCAR=25.8
190 57548 my $class = shift;
191 57548 my %p = @_;
192  
193 57548 ▶ Carp::croak('Constructor called with reference, we expected a package')
Branch: 1 branch
BranchTrueFalseTotal
if ref $class 2 57546 57548
194 if ref $class;
195  
196 # If this method is called from somewhere other than new(), then some of
197 # these defaults may not get applied.
198 57546 ▶ $p{month} = 1 unless exists $p{month};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $p{"month"} 0 57546 57546
199 57546 ▶ $p{day} = 1 unless exists $p{day};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $p{"day"} 0 57546 57546
200 57546 ▶ $p{hour} = 0 unless exists $p{hour};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $p{"hour"} 0 57546 57546
201 57546 ▶ $p{minute} = 0 unless exists $p{minute};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $p{"minute"} 0 57546 57546
202 57546 ▶ $p{second} = 0 unless exists $p{second};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $p{"second"} 0 57546 57546
203 57546 ▶ $p{nanosecond} = 0 unless exists $p{nanosecond};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $p{"nanosecond"} 46 57500 57546
204 57546 ▶ $p{time_zone} = $class->_default_time_zone unless exists $p{time_zone};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $p{"time_zone"} 1330 56216 57546
205  
206 57546 my $self = bless {}, $class;
207  
208 57546 $self->_set_locale( $p{locale} );
209  
210 $self->{tz} = (
211 ref $p{time_zone}
212 ? $p{time_zone}
213 : DateTime::TimeZone->new( name => $p{time_zone} )
214 57546 ▶ );
Branch: 1 branch
BranchTrueFalseTotal
ref $p{'time_zone'} ? : 201 57345 57546
215  
216 57546 $self->{local_rd_days} = $class->_ymd2rd( @p{qw( year month day )} );
217  
218 $self->{local_rd_secs}
219 57546 = $class->_time_as_seconds( @p{qw( hour minute second )} );
220  
221 57546 $self->{offset_modifier} = 0;
222  
223 57546 $self->{rd_nanosecs} = $p{nanosecond};
224 57546 $self->{formatter} = $p{formatter};
225  
226 $self->_normalize_nanoseconds(
227 $self->{local_rd_secs},
228 $self->{rd_nanosecs}
229 57546 );
230  
231 # Set this explicitly since it can't be calculated accurately
232 # without knowing our time zone offset, and it's possible that the
233 # offset can't be calculated without having at least a rough guess
234 # of the datetime's year. This year need not be correct, as long
235 # as its equal or greater to the correct number, so we fudge by
236 # adding one to the local year given to the constructor.
237 57546 $self->{utc_year} = $p{year} + 1;
238  
239 57546 $self->_maybe_future_dst_warning( $p{year}, $p{time_zone} );
240  
241 57546 $self->_calc_utc_rd;
242  
243 57543 $self->_handle_offset_modifier( $p{second} );
244  
245 57543 $self->_calc_local_rd;
246  
247 57543 ▶ if ( $p{second} > 59 ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p{"second"} > 59) 49 57494 57543
248 49 ▶ if (
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{"tz"}->is_floating or $self->{"utc_rd_secs"} - 86399 < $p{"second"} - 59) 3 46 49
Condition100%3/3
$self->{"tz"}->is_floating or $self->{"utc_rd_secs"} - 86399 < $p{"second"} - 59
l!l&&r!l&&!r
1246
MC/DC100%2/2
$self->{"tz"}->is_floating or $self->{"utc_rd_secs"} - 86399 < $p{"second"} - 59
$self->{"tz"}->is_floating $self->{"utc_rd_secs"} - 86399 < $p{"second"} - 59
Truth table100%3/3
A or B
A= $self->{"tz"}->is_floatingB= $self->{"utc_rd_secs"} - 86399 < $p{"second"} - 59
ABresult
1X1
011
000
249 $self->{tz}->is_floating
250 ||
251  
252 # If true, this means that the actual calculated leap
253 # second does not occur in the second given to new()
254 ( $self->{utc_rd_secs} - 86399 < $p{second} - 59 )
255 ) {
256 3 Carp::croak("Invalid second value ($p{second})\n");
257 }
258 }
259  
260 57540 return $self;
261 }
262  
263 # Warning: do not use this environment variable unless you have no choice in
264 # the matter.
265 1332 ▶sub _default_time_zone {
Subroutine _default_time_zone: called CC=2 SCAR=6.9
266 1332 ▶ return $ENV{PERL_DATETIME_DEFAULT_TZ} || 'floating';
Condition100%2/2
$ENV{'PERL_DATETIME_DEFAULT_TZ'} || 'floating'
l!l
41328
MC/DC100%1/1
$ENV{'PERL_DATETIME_DEFAULT_TZ'} || 'floating'
$ENV{'PERL_DATETIME_DEFAULT_TZ'}
Truth table100%2/2
A
A= $ENV{'PERL_DATETIME_DEFAULT_TZ'}
Aresult
11
00
267 }
268  
269 57549 ▶sub _set_locale {
Subroutine _set_locale: called CC=4 SCAR=13.9
270 57549 my $self = shift;
271 57549 my $locale = shift;
272  
273 57549 ▶ if ( defined $locale && ref $locale ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $locale and ref $locale) { } 32127 25422 57549
Condition100%3/3
defined $locale and ref $locale
!ll&&!rl&&r
253962632127
MC/DC100%2/2
defined $locale and ref $locale
defined $locale ref $locale
Truth table100%3/3
A and B
A= defined $localeB= ref $locale
ABresult
0X0
100
111
274 32127 $self->{locale} = $locale;
275 }
276 else {
277 $self->{locale}
278 25422 ▶ = $locale
Branch: 1 branch
BranchTrueFalseTotal
$locale ? : 26 25396 25422
279 ? DateTime::Locale->load($locale)
280 : $self->DefaultLocale;
281 }
282  
283 57549 return;
284 }
285  
286 # This method exists for the benefit of internal methods which create
287 # a new object based on the current object, like set() and truncate().
288 201 ▶sub _new_from_self {
Subroutine _new_from_self: called CC=3 SCAR=11.0
289 201 my $self = shift;
290 201 my %p = @_;
291  
292 201 my %old = map { $_ => $self->$_() } qw(
293 year month day
294 hour minute second
295 nanosecond
296 locale time_zone
297 );
298 201 ▶ $old{formatter} = $self->formatter
Branch: 1 branch
BranchTrueFalseTotal
if defined $self->formatter 2 199 201
299 if defined $self->formatter;
300  
301 201 ▶ my $method = delete $p{_skip_validation} ? '_new' : 'new';
Branch: 1 branch
BranchTrueFalseTotal
delete $p{'_skip_validation'} ? : 169 32 201
302  
303 201 return ( ref $self )->$method( %old, %p );
304 }
305  
306 120815 ▶sub _handle_offset_modifier {
Subroutine _handle_offset_modifier: called CC=19 SCAR=29.5
307 120815 my $self = shift;
308  
309 120815 $self->{offset_modifier} = 0;
310  
311 120815 ▶ return if $self->{tz}->is_floating;
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"tz"}->is_floating 87156 33659 120815
312  
313 33659 my $second = shift;
314 33659 my $utc_is_valid = shift;
315  
316 33659 my $utc_rd_days = $self->{utc_rd_days};
317  
318 33659 ▶ my $offset
Branch: 1 branch
BranchTrueFalseTotal
$utc_is_valid ? : 161 33498 33659
319 = $utc_is_valid ? $self->offset : $self->_offset_for_local_datetime;
320  
321 33659 ▶ if ( $offset >= 0
Branch: 2 branches
BranchTrueFalseTotal
if ($offset >= 0 and $self->{'local_rd_secs'} >= $offset) { } 33387 272 33659
elsif ($offset < 0 and $self->{'local_rd_secs'} >= 86400 + $offset) { } 28 284 312
Condition100%3/3
$offset >= 0 and $self->{"local_rd_secs"} >= $offset
!ll&&!rl&&r
2324033387
MC/DC100%2/2
$offset >= 0 and $self->{"local_rd_secs"} >= $offset
$offset >= 0 $self->{"local_rd_secs"} >= $offset
Truth table100%3/3
A and B
A= $offset >= 0B= $self->{"local_rd_secs"} >= $offset
ABresult
0X0
100
111
322 && $self->{local_rd_secs} >= $offset ) {
323 33387 ▶ if ( $second < 60 && $offset > 0 ) {
Branch: 2 branches
BranchTrueFalseTotal
if ($second < 60 and $offset > 0) { } 45 33342 33387
elsif ($second == 60 and $self->{'local_rd_secs'} == $offset && $offset > 0 || $offset == 0 && $self->{'local_rd_secs'} > 86399) { } 42 66591 66633
Condition100%3/3
$second < 60 and $offset > 0
!ll&&!rl&&r
643327845
MC/DC100%2/2
$second < 60 and $offset > 0
$second < 60 $offset > 0
Truth table100%3/3
A and B
A= $second < 60B= $offset > 0
ABresult
0X0
100
111
324 $self->{offset_modifier}
325 45 = $self->_day_length( $utc_rd_days - 1 ) - SECONDS_PER_DAY;
326  
327 45 $self->{local_rd_secs} += $self->{offset_modifier};
328 }
329 ▶ elsif (
Condition91%11/12
$second == 60 and $self->{"local_rd_secs"} == $offset && $offset > 0 || $offset == 0 && $self->{"local_rd_secs"} > 86399
!ll&&!rl&&r
332891142
$self->{"local_rd_secs"} == $offset and $offset > 0 or $offset == 0 and $self->{"local_rd_secs"} > 86399
l!l&&r!l&&!r
33911
$self->{"local_rd_secs"} == $offset and $offset > 0
!ll&&!rl&&r
5003
$offset == 0 and $self->{"local_rd_secs"} > 86399
!ll&&!rl&&r
2939
MC/DC80%4/5
$second == 60 and $self->{"local_rd_secs"} == $offset && $offset > 0 || $offset == 0 && $self->{"local_rd_secs"} > 86399
$second == 60 $self->{"local_rd_secs"} == $offset $offset > 0 $offset == 0 $self->{"local_rd_secs"} > 86399
Truth table62%5/8
A and B and C or D and E
A= $second == 60B= $self->{"local_rd_secs"} == $offsetC= $offset > 0D= $offset == 0E= $self->{"local_rd_secs"} > 86399
ABCDEresult
0XXXX0
10X0X0
10X100
1100X0
110100
111XX1
10X111
110111
330 $second == 60
331 && (
332 ( $self->{local_rd_secs} == $offset && $offset > 0 )
333 || ( $offset == 0
334 && $self->{local_rd_secs} > 86399 )
335 )
336 ) {
337 42 my $mod
338 = $self->_day_length( $utc_rd_days - 1 ) - SECONDS_PER_DAY;
339  
340 42 ▶ unless ( $mod == 0 ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($mod == 0) 41 1 42
341 41 $self->{utc_rd_secs} -= $mod;
342  
343 41 $self->_normalize_seconds;
344 }
345 }
346 }
347 ▶ elsif ($offset < 0
Condition100%3/3
$offset < 0 and $self->{"local_rd_secs"} >= 86400 + $offset
!ll&&!rl&&r
4020428
MC/DC100%2/2
$offset < 0 and $self->{"local_rd_secs"} >= 86400 + $offset
$offset < 0 $self->{"local_rd_secs"} >= 86400 + $offset
Truth table100%3/3
A and B
A= $offset < 0B= $self->{"local_rd_secs"} >= 86400 + $offset
ABresult
0X0
100
111
348 && $self->{local_rd_secs} >= SECONDS_PER_DAY + $offset ) {
349 28 ▶ if ( $second < 60 ) {
Branch: 2 branches
BranchTrueFalseTotal
if ($second < 60) { } 21 7 28
elsif ($second == 60 and $self->{'local_rd_secs'} == 86400 + $offset) { } 5 2 7
350 $self->{offset_modifier}
351 21 = $self->_day_length( $utc_rd_days - 1 ) - SECONDS_PER_DAY;
352  
353 21 $self->{local_rd_secs} += $self->{offset_modifier};
354 }
355 ▶ elsif ($second == 60
Condition66%2/3
$second == 60 and $self->{"local_rd_secs"} == 86400 + $offset
!ll&&!rl&&r
025
MC/DC50%1/2
$second == 60 and $self->{"local_rd_secs"} == 86400 + $offset
$second == 60 $self->{"local_rd_secs"} == 86400 + $offset
Truth table66%2/3
A and B
A= $second == 60B= $self->{"local_rd_secs"} == 86400 + $offset
ABresult
0X0
100
111
356 && $self->{local_rd_secs} == SECONDS_PER_DAY + $offset ) {
357 5 my $mod
358 = $self->_day_length( $utc_rd_days - 1 ) - SECONDS_PER_DAY;
359  
360 5 ▶ unless ( $mod == 0 ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($mod == 0) 5 0 5
361 5 $self->{utc_rd_secs} -= $mod;
362  
363 5 $self->_normalize_seconds;
364 }
365 }
366 }
367 }
368  
369 113185 ▶sub _calc_utc_rd {
Subroutine _calc_utc_rd: called CC=3 SCAR=11.0
370 113185 my $self = shift;
371  
372 113185 delete $self->{utc_c};
373  
374 113185 ▶ if ( $self->{tz}->is_utc || $self->{tz}->is_floating ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{'tz'}->is_utc or $self->{'tz'}->is_floating) { } 113007 178 113185
Condition100%3/3
$self->{"tz"}->is_utc or $self->{"tz"}->is_floating
l!l&&r!l&&!r
3328779720178
MC/DC100%2/2
$self->{"tz"}->is_utc or $self->{"tz"}->is_floating
$self->{"tz"}->is_utc $self->{"tz"}->is_floating
Truth table100%3/3
A or B
A= $self->{"tz"}->is_utcB= $self->{"tz"}->is_floating
ABresult
1X1
011
000
375 113007 $self->{utc_rd_days} = $self->{local_rd_days};
376 113007 $self->{utc_rd_secs} = $self->{local_rd_secs};
377 }
378 else {
379 178 my $offset = $self->_offset_for_local_datetime;
380  
381 172 $offset += $self->{offset_modifier};
382  
383 172 $self->{utc_rd_days} = $self->{local_rd_days};
384 172 $self->{utc_rd_secs} = $self->{local_rd_secs} - $offset;
385 }
386  
387 # We account for leap seconds in the new() method and nowhere else
388 # except date math.
389 $self->_normalize_tai_seconds(
390 $self->{utc_rd_days},
391 $self->{utc_rd_secs}
392 113179 );
393 }
394  
395 7623 ▶sub _normalize_seconds {
Subroutine _normalize_seconds: called CC=4 SCAR=13.9
396 7623 my $self = shift;
397  
398 7623 ▶ return if $self->{utc_rd_secs} >= 0 && $self->{utc_rd_secs} <= 86399;
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"utc_rd_secs"} >= 0 and $self->{"utc_rd_secs"} <= 86399 7545 78 7623
Condition100%3/3
$self->{"utc_rd_secs"} >= 0 and $self->{"utc_rd_secs"} <= 86399
!ll&&!rl&&r
57217545
MC/DC100%2/2
$self->{"utc_rd_secs"} >= 0 and $self->{"utc_rd_secs"} <= 86399
$self->{"utc_rd_secs"} >= 0 $self->{"utc_rd_secs"} <= 86399
Truth table100%3/3
A and B
A= $self->{"utc_rd_secs"} >= 0B= $self->{"utc_rd_secs"} <= 86399
ABresult
0X0
100
111
399  
400 78 ▶ if ( $self->{tz}->is_floating ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{'tz'}->is_floating) { } 3 75 78
401 $self->_normalize_tai_seconds(
402 $self->{utc_rd_days},
403 $self->{utc_rd_secs}
404 3 );
405 }
406 else {
407 $self->_normalize_leap_seconds(
408 $self->{utc_rd_days},
409 $self->{utc_rd_secs}
410 75 );
411 }
412 }
413  
414 57797 ▶sub _calc_local_rd {
Subroutine _calc_local_rd: called CC=3 SCAR=11.0
415 57797 my $self = shift;
416  
417 57797 delete $self->{local_c};
418  
419 # We must short circuit for UTC times or else we could end up with
420 # loops between DateTime.pm and DateTime::TimeZone
421 57797 ▶ if ( $self->{tz}->is_utc || $self->{tz}->is_floating ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{'tz'}->is_utc or $self->{'tz'}->is_floating) { } 57539 258 57797
Condition100%3/3
$self->{"tz"}->is_utc or $self->{"tz"}->is_floating
l!l&&r!l&&!r
3275924780258
MC/DC100%2/2
$self->{"tz"}->is_utc or $self->{"tz"}->is_floating
$self->{"tz"}->is_utc $self->{"tz"}->is_floating
Truth table100%3/3
A or B
A= $self->{"tz"}->is_utcB= $self->{"tz"}->is_floating
ABresult
1X1
011
000
422 57539 $self->{local_rd_days} = $self->{utc_rd_days};
423 57539 $self->{local_rd_secs} = $self->{utc_rd_secs};
424 }
425 else {
426 258 my $offset = $self->offset;
427  
428 258 $self->{local_rd_days} = $self->{utc_rd_days};
429 258 $self->{local_rd_secs} = $self->{utc_rd_secs} + $offset;
430  
431 # intentionally ignore leap seconds here
432 $self->_normalize_tai_seconds(
433 $self->{local_rd_days},
434 $self->{local_rd_secs}
435 258 );
436  
437 258 $self->{local_rd_secs} += $self->{offset_modifier};
438 }
439  
440 57797 $self->_calc_local_components;
441 }
442  
443 57797 ▶sub _calc_local_components {
Subroutine _calc_local_components: called CC=1 SCAR=0.0
444 57797 my $self = shift;
445  
446 57797 @{ $self->{local_c} }{
447 qw( year month day day_of_week
448 day_of_year quarter day_of_quarter)
449 }
450 57797 = $self->_rd2ymd( $self->{local_rd_days}, 1 );
451  
452 57797 @{ $self->{local_c} }{qw( hour minute second )}
453 = $self->_seconds_as_components(
454 $self->{local_rd_secs},
455 $self->{utc_rd_secs}, $self->{offset_modifier}
456 57797 );
457 }
458  
459 {
460 49 my $named_validator = validation_for(
461 name => '_check_named_from_epoch_params',
462 name_is_optional => 1,
463 params => {
464 epoch => { type => t('Num') },
465 formatter => {
466 type => t('Formatter'),
467 optional => 1
468 },
469 locale => {
470 type => t('Locale'),
471 optional => 1
472 },
473 time_zone => {
474 type => t('TimeZone'),
475 optional => 1
476 },
477 },
478 );
479  
480 49 my $one_param_validator = validation_for(
481 name => '_check_one_from_epoch_param',
482 name_is_optional => 1,
483 params => [ { type => t('Num') } ],
484 );
485  
486 59 ▶ sub from_epoch {
Subroutine from_epoch: called CC=6 SCAR=17.9
Pod documented
487 59 my $class = shift;
488 59 my %p;
489 59 ▶ if ( @_ == 1 && !is_HashRef( $_[0] ) ) {
Branch: 1 branch
BranchTrueFalseTotal
if (@_ == 1 and not is_HashRef($_[0])) { } 3 56 59
Condition66%2/3
@_ == 1 and not is_HashRef($_[0])
!ll&&!rl&&r
5603
MC/DC50%1/2
@_ == 1 and not is_HashRef($_[0])
@_ == 1 not is_HashRef($_[0])
Truth table66%2/3
A and not(B)
A= @_ == 1B= not is_HashRef($_[0])
ABresult
0X0
100
111
490 3 ( $p{epoch} ) = $one_param_validator->(@_);
491 }
492 else {
493 56 %p = $named_validator->(@_);
494 }
495  
496 56 my %args;
497  
498 # This does two things. First, if given a negative non-integer epoch,
499 # it will round the epoch _down_ to the next second and then adjust
500 # the nanoseconds to be positive. In other words, -0.5 corresponds to
501 # a second of -1 and a nanosecond value of 500,000. Before this code
502 # was implemented our handling of negative non-integer epochs was
503 # quite broken, and would end up rounding some values up, so that -0.5
504 # become 0.5 (which is obviously wrong!).
505 #
506 # Second, it rounds any decimal values to the nearest microsecond
507 # (1E6). Here's what Christian Hansen, who wrote this patch, says:
508 #
509 # Perl is typically compiled with NV as a double. A double with a
510 # significand precision of 53 bits can only represent a nanosecond
511 # epoch without loss of precision if the duration from zero epoch
512 # is less than ≈ ±104 days. With microseconds the duration is
513 # ±104,000 days, which is ≈ ±285 years.
514 56 ▶ if ( int $p{epoch} != $p{epoch} ) {
Branch: 1 branch
BranchTrueFalseTotal
if (int $p{"epoch"} != $p{"epoch"}) 8 48 56
515 8 my ( $floor, $nano, $second );
516  
517 8 $floor = $nano = fmod( $p{epoch}, 1.0 );
518 8 $second = floor( $p{epoch} - $floor );
519 8 ▶ if ( $nano < 0 ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($nano < 0) 2 6 8
520 2 $nano += 1;
521 }
522 8 $p{epoch} = $second + floor( $floor - $nano );
523 8 $args{nanosecond} = floor( $nano * 1E6 + 0.5 ) * 1E3;
524 }
525  
526 # Note, for very large negative values this may give a
527 # blatantly wrong answer.
528 @args{qw( second minute hour day month year )}
529 56 = ( gmtime( $p{epoch} ) )[ 0 .. 5 ];
530 56 $args{year} += 1900;
531 56 $args{month}++;
532  
533 56 my $self = $class->_new( %p, %args, time_zone => 'UTC' );
534  
535 54 $self->_maybe_future_dst_warning( $self->year, $p{time_zone} );
536  
537 54 ▶ $self->set_time_zone( $p{time_zone} ) if exists $p{time_zone};
Branch: 1 branch
BranchTrueFalseTotal
if exists $p{"time_zone"} 4 50 54
538  
539 54 return $self;
540 }
541 }
542  
543 49 ▶sub now {
Subroutine now: called CC=1 SCAR=0.0
Pod documented
544 31 my $class = shift;
545 31 return $class->from_epoch( epoch => $class->_core_time, @_ );
546 }
547  
548 57600 ▶sub _maybe_future_dst_warning {
Subroutine _maybe_future_dst_warning: called CC=6 SCAR=18.0
549 57600 shift;
550 57600 my $year = shift;
551 57600 my $tz = shift;
552  
553 57600 ▶ return unless $year >= 5000 && $tz;
Branch: 1 branch
BranchTrueFalseTotal
unless $year >= 5000 and $tz 57590 10 57600
Condition66%2/3
$year >= 5000 and $tz
!ll&&!rl&&r
57590010
MC/DC50%1/2
$year >= 5000 and $tz
$year >= 5000 $tz
Truth table66%2/3
A and B
A= $year >= 5000B= $tz
ABresult
0X0
100
111
554  
555 10 ▶ my $tz_name = ref $tz ? $tz->name : $tz;
Branch: 1 branch
BranchTrueFalseTotal
ref $tz ? : 0 10 10
556 10 ▶ return if $tz_name eq 'floating' || $tz_name eq 'UTC';
Branch: 1 branch
BranchTrueFalseTotal
if $tz_name eq "floating" or $tz_name eq "UTC" 5 5 10
Condition100%3/3
$tz_name eq "floating" or $tz_name eq "UTC"
l!l&&r!l&&!r
235
MC/DC100%2/2
$tz_name eq "floating" or $tz_name eq "UTC"
$tz_name eq "floating" $tz_name eq "UTC"
Truth table100%3/3
A or B
A= $tz_name eq "floating"B= $tz_name eq "UTC"
ABresult
1X1
011
000
557  
558 5 warnings::warnif(
559 "You are creating a DateTime object with a far future year ($year) and a time zone ($tz_name)."
560 . ' If the time zone you specified has future DST changes this will be very slow.'
561 );
562 }
563  
564 # use scalar time in case someone's loaded Time::Piece
565 30 ▶sub _core_time {
Subroutine _core_time: called CC=1 SCAR=0.0
566 30 return scalar time;
567 }
568  
569 3 ▶sub today { shift->now(@_)->truncate( to => 'day' ) }
Subroutine today: called CC=1 SCAR=0.0
Pod documented
570  
571 {
572 49 my $validator = validation_for(
573 name => '_check_from_object_params',
574 name_is_optional => 1,
575 params => {
576 object => { type => t('ConvertibleObject') },
577 locale => {
578 type => t('Locale'),
579 optional => 1,
580 },
581 formatter => {
582 type => t('Formatter'),
583 optional => 1,
584 },
585 },
586 );
587  
588 31935 ▶ sub from_object {
Subroutine from_object: called CC=8 SCAR=20.8
Pod documented
589 31935 my $class = shift;
590 31935 my %p = $validator->(@_);
591  
592 31935 my $object = delete $p{object};
593  
594 31935 ▶ if ( $object->isa('DateTime::Infinite') ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($object->isa("DateTime::Infinite")) 2 31933 31935
595 2 return $object->clone;
596 }
597  
598 31933 my ( $rd_days, $rd_secs, $rd_nanosecs ) = $object->utc_rd_values;
599  
600 # A kludge because until all calendars are updated to return all
601 # three values, $rd_nanosecs could be undef
602 31933 ▶ $rd_nanosecs ||= 0;
Condition100%2/2
$rd_nanosecs ||= 0
l!l
731926
MC/DC100%1/1
$rd_nanosecs ||= 0
$rd_nanosecs
Truth table100%2/2
A
A= $rd_nanosecs
Aresult
11
00
603  
604 # This is a big hack to let _seconds_as_components operate naively
605 # on the given value. If the object _is_ on a leap second, we'll
606 # add that to the generated seconds value later.
607 31933 my $leap_seconds = 0;
608 31933 ▶ if ( $object->can('time_zone')
Branch: 1 branch
BranchTrueFalseTotal
if ($object->can("time_zone") and not $object->time_zone->is_floating and $rd_secs > 86399 and $rd_secs <= $class->_day_length($rd_days)) 6 31927 31933
Condition88%8/9
$object->can("time_zone") and not $object->time_zone->is_floating and $rd_secs > 86399 and $rd_secs <= $class->_day_length($rd_days)
!ll&&!rl&&r
3192706
$object->can("time_zone") and not $object->time_zone->is_floating and $rd_secs > 86399
!ll&&!rl&&r
312406876
$object->can("time_zone") and not $object->time_zone->is_floating
!ll&&!rl&&r
231238693
MC/DC75%3/4
$object->can("time_zone") and not $object->time_zone->is_floating and $rd_secs > 86399 and $rd_secs <= $class->_day_length($rd_days)
$object->can("time_zone") not $object->time_zone->is_floating $rd_secs > 86399 $rd_secs <= $class->_day_length($rd_days)
Truth table80%4/5
A and not(B) and C and D
A= $object->can("time_zone")B= not $object->time_zone->is_floatingC= $rd_secs > 86399D= $rd_secs <= $class->_day_length($rd_days)
ABCDresult
0XXX0
10XX0
110X0
11100
11111
609 && !$object->time_zone->is_floating
610 && $rd_secs > 86399
611 && $rd_secs <= $class->_day_length($rd_days) ) {
612 6 $leap_seconds = $rd_secs - 86399;
613 6 $rd_secs -= $leap_seconds;
614 }
615  
616 31933 my %args;
617 31933 @args{qw( year month day )} = $class->_rd2ymd($rd_days);
618 31933 @args{qw( hour minute second )}
619 = $class->_seconds_as_components($rd_secs);
620 31933 $args{nanosecond} = $rd_nanosecs;
621  
622 31933 $args{second} += $leap_seconds;
623  
624 31933 my $new = $class->new( %p, %args, time_zone => 'UTC' );
625  
626 31933 ▶ if ( $object->can('time_zone') ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($object->can('time_zone')) { } 31931 2 31933
627 31931 $new->set_time_zone( $object->time_zone );
628 }
629 else {
630 2 $new->set_time_zone( $class->_default_time_zone );
631 }
632  
633 31933 return $new;
634 }
635 }
636  
637 {
638 49 my $validator = validation_for(
639 name => '_check_last_day_of_month_params',
640 name_is_optional => 1,
641 params => {
642 year => { type => t('Year') },
643 month => { type => t('Month') },
644 day => {
645 type => t('DayOfMonth'),
646 default => 1,
647 },
648 hour => {
649 type => t('Hour'),
650 default => 0,
651 },
652 minute => {
653 type => t('Minute'),
654 default => 0,
655 },
656 second => {
657 type => t('Second'),
658 default => 0,
659 },
660 nanosecond => {
661 type => t('Nanosecond'),
662 default => 0,
663 },
664 locale => {
665 type => t('Locale'),
666 optional => 1,
667 },
668 formatter => {
669 type => t('Formatter'),
670 optional => 1,
671 },
672 time_zone => {
673 type => t('TimeZone'),
674 optional => 1,
675 },
676 },
677 );
678  
679 7464 ▶ sub last_day_of_month {
Subroutine last_day_of_month: called CC=1 SCAR=0.0
Pod documented
680 7464 my $class = shift;
681 7464 my %p = $validator->(@_);
682  
683 7462 my $day = $class->_month_length( $p{year}, $p{month} );
684  
685 7462 return $class->_new( %p, day => $day );
686 }
687 }
688  
689 49 ▶sub _month_length {
Subroutine _month_length: called CC=2 SCAR=6.9
690 return (
691 40116 ▶ $_[0]->_is_leap_year( $_[1] )
Branch: 1 branch
BranchTrueFalseTotal
$_[0]->_is_leap_year($_[1]) ? : 10445 29671 40116
692 ? $LeapYearMonthLengths[ $_[2] - 1 ]
693 : $MonthLengths[ $_[2] - 1 ]
694 );
695 }
696  
697 {
698 49 my $validator = validation_for(
699 name => '_check_from_day_of_year_params',
700 name_is_optional => 1,
701 params => {
702 year => { type => t('Year') },
703 day_of_year => { type => t('DayOfYear') },
704 hour => {
705 type => t('Hour'),
706 default => 0,
707 },
708 minute => {
709 type => t('Minute'),
710 default => 0,
711 },
712 second => {
713 type => t('Second'),
714 default => 0,
715 },
716 nanosecond => {
717 type => t('Nanosecond'),
718 default => 0,
719 },
720 locale => {
721 type => t('Locale'),
722 optional => 1,
723 },
724 formatter => {
725 type => t('Formatter'),
726 optional => 1,
727 },
728 time_zone => {
729 type => t('TimeZone'),
730 optional => 1,
731 },
732 },
733 );
734  
735 1124 ▶ sub from_day_of_year {
Subroutine from_day_of_year: called CC=5 SCAR=16.1
Pod documented
736 1124 my $class = shift;
737 1124 my %p = $validator->(@_);
738  
739 Carp::croak("$p{year} is not a leap year.\n")
740 1124 ▶ if $p{day_of_year} == 366 && !$class->_is_leap_year( $p{year} );
Branch: 1 branch
BranchTrueFalseTotal
if $p{"day_of_year"} == 366 and not $class->_is_leap_year($p{"year"}) 1 1123 1124
Condition100%3/3
$p{"day_of_year"} == 366 and not $class->_is_leap_year($p{"year"})
!ll&&!rl&&r
112121
MC/DC100%2/2
$p{"day_of_year"} == 366 and not $class->_is_leap_year($p{"year"})
$p{"day_of_year"} == 366 not $class->_is_leap_year($p{"year"})
Truth table100%3/3
A and not(B)
A= $p{"day_of_year"} == 366B= not $class->_is_leap_year($p{"year"})
ABresult
0X0
100
111
741  
742 1123 my $month = 1;
743 1123 my $day = delete $p{day_of_year};
744  
745 1123 ▶ if ( $day > 31 ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($day > 31) 1028 95 1123
746 1028 my $length = $class->_month_length( $p{year}, $month );
747  
748 1028 ▶ while ( $day > $length ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($day > $length) 6207 1028 7235
749 6207 $day -= $length;
750 6207 $month++;
751 6207 $length = $class->_month_length( $p{year}, $month );
752 }
753 }
754  
755 1123 return $class->_new(
756 %p,
757 month => $month,
758 day => $day,
759 );
760 }
761 }
762  
763 206 ▶sub formatter { $_[0]->{formatter} }
Subroutine formatter: called CC=1 SCAR=0.0
Pod documented
764  
765 32046 ▶sub clone { bless { %{ $_[0] } }, ref $_[0] }
Subroutine clone: called CC=1 SCAR=0.0
Pod documented
766  
767 1747 ▶sub year {
Subroutine year: called CC=2 SCAR=6.9
Pod documented
768 1747 ▶ Carp::carp('year() is a read-only accessor') if @_ > 1;
Branch: 1 branch
BranchTrueFalseTotal
if @_ > 1 1 1746 1747
769 1747 return $_[0]->{local_c}{year};
770 }
771  
772 23 ▶sub ce_year {
Subroutine ce_year: called CC=2 SCAR=6.9
Pod documented
773 $_[0]->{local_c}{year} <= 0
774 ? $_[0]->{local_c}{year} - 1
775 23 ▶ : $_[0]->{local_c}{year};
Branch: 1 branch
BranchTrueFalseTotal
$_[0]{'local_c'}{'year'} <= 0 ? : 12 11 23
776 }
777  
778 2 ▶sub era_name { $_[0]->{locale}->era_wide->[ $_[0]->_era_index ] }
Subroutine era_name: called CC=1 SCAR=0.0
Pod documented
779  
780 10 ▶sub era_abbr { $_[0]->{locale}->era_abbreviated->[ $_[0]->_era_index ] }
Subroutine era_abbr: called CC=1 SCAR=0.0
Pod documented
781  
782 # deprecated
783 49 *era = \&era_abbr;
784  
785 13 ▶sub _era_index { $_[0]->{local_c}{year} <= 0 ? 0 : 1 }
Subroutine _era_index: called CC=2 SCAR=6.9
Branch: 1 branch
BranchTrueFalseTotal
$_[0]{'local_c'}{'year'} <= 0 ? : 2 11 13
786  
787 4 ▶sub christian_era { $_[0]->ce_year > 0 ? 'AD' : 'BC' }
Subroutine christian_era: called CC=2 SCAR=6.9
Pod documented
Branch: 1 branch
BranchTrueFalseTotal
$_[0]->ce_year > 0 ? : 2 2 4
788 4 ▶sub secular_era { $_[0]->ce_year > 0 ? 'CE' : 'BCE' }
Subroutine secular_era: called CC=2 SCAR=6.9
Pod documented
Branch: 1 branch
BranchTrueFalseTotal
$_[0]->ce_year > 0 ? : 2 2 4
789  
790 2 ▶sub year_with_era { ( abs $_[0]->ce_year ) . $_[0]->era_abbr }
Subroutine year_with_era: called CC=1 SCAR=0.0
Pod documented
791 2 ▶sub year_with_christian_era { ( abs $_[0]->ce_year ) . $_[0]->christian_era }
Subroutine year_with_christian_era: called CC=1 SCAR=0.0
Pod documented
792 2 ▶sub year_with_secular_era { ( abs $_[0]->ce_year ) . $_[0]->secular_era }
Subroutine year_with_secular_era: called CC=1 SCAR=0.0
Pod documented
793  
794 8618 ▶sub month {
Subroutine month: called CC=2 SCAR=6.9
Pod documented
795 8618 ▶ Carp::carp('month() is a read-only accessor') if @_ > 1;
Branch: 1 branch
BranchTrueFalseTotal
if @_ > 1 1 8617 8618
796 8618 return $_[0]->{local_c}{month};
797 }
798 49 *mon = \&month;
799  
800 20 ▶sub month_0 { $_[0]->{local_c}{month} - 1 }
Subroutine month_0: called CC=1 SCAR=0.0
Pod undocumented
801 49 *mon_0 = \&month_0;
802  
803 7 ▶sub month_name { $_[0]->{locale}->month_format_wide->[ $_[0]->month_0 ] }
Subroutine month_name: called CC=1 SCAR=0.0
Pod documented
804  
805 8 ▶sub month_abbr {
Subroutine month_abbr: called CC=1 SCAR=0.0
Pod documented
806 8 $_[0]->{locale}->month_format_abbreviated->[ $_[0]->month_0 ];
807 }
808  
809 15910 ▶sub day_of_month {
Subroutine day_of_month: called CC=2 SCAR=6.9
Pod undocumented
810 15910 ▶ Carp::carp('day_of_month() is a read-only accessor') if @_ > 1;
Branch: 1 branch
BranchTrueFalseTotal
if @_ > 1 1 15909 15910
811 15910 $_[0]->{local_c}{day};
812 }
813 49 *day = \&day_of_month;
814 49 *mday = \&day_of_month;
815  
816 49 ▶sub weekday_of_month { use integer; ( ( $_[0]->day - 1 ) / 7 ) + 1 }
Subroutine BEGIN: called CC=1 SCAR=0.0
Subroutine weekday_of_month: called CC=1 SCAR=0.0
Pod documented
817  
818 30 ▶sub quarter { $_[0]->{local_c}{quarter} }
Subroutine quarter: called CC=1 SCAR=0.0
Pod documented
819  
820 2 ▶sub quarter_name {
Subroutine quarter_name: called CC=1 SCAR=0.0
Pod documented
821 2 $_[0]->{locale}->quarter_format_wide->[ $_[0]->quarter_0 ];
822 }
823  
824 2 ▶sub quarter_abbr {
Subroutine quarter_abbr: called CC=1 SCAR=0.0
Pod documented
825 2 $_[0]->{locale}->quarter_format_abbreviated->[ $_[0]->quarter_0 ];
826 }
827  
828 6 ▶sub quarter_0 { $_[0]->{local_c}{quarter} - 1 }
Subroutine quarter_0: called CC=1 SCAR=0.0
Pod undocumented
829  
830 6 ▶sub day_of_month_0 { $_[0]->{local_c}{day} - 1 }
Subroutine day_of_month_0: called CC=1 SCAR=0.0
Pod undocumented
831 49 *day_0 = \&day_of_month_0;
832 49 *mday_0 = \&day_of_month_0;
833  
834 32698 ▶sub day_of_week { $_[0]->{local_c}{day_of_week} }
Subroutine day_of_week: called CC=1 SCAR=0.0
Pod documented
835 49 *wday = \&day_of_week;
836 49 *dow = \&day_of_week;
837  
838 23 ▶sub day_of_week_0 { $_[0]->{local_c}{day_of_week} - 1 }
Subroutine day_of_week_0: called CC=1 SCAR=0.0
Pod undocumented
839 49 *wday_0 = \&day_of_week_0;
840 49 *dow_0 = \&day_of_week_0;
841  
842 4 ▶sub local_day_of_week {
Subroutine local_day_of_week: called CC=1 SCAR=0.0
Pod documented
843 4 my $self = shift;
844 return 1
845 4 + ( $self->day_of_week - $self->{locale}->first_day_of_week ) % 7;
846 }
847  
848 7 ▶sub day_name { $_[0]->{locale}->day_format_wide->[ $_[0]->day_of_week_0 ] }
Subroutine day_name: called CC=1 SCAR=0.0
Pod documented
849  
850 8 ▶sub day_abbr {
Subroutine day_abbr: called CC=1 SCAR=0.0
Pod documented
851 8 $_[0]->{locale}->day_format_abbreviated->[ $_[0]->day_of_week_0 ];
852 }
853  
854 18 ▶sub day_of_quarter { $_[0]->{local_c}{day_of_quarter} }
Subroutine day_of_quarter: called CC=1 SCAR=0.0
Pod documented
855 49 *doq = \&day_of_quarter;
856  
857 2 ▶sub day_of_quarter_0 { $_[0]->day_of_quarter - 1 }
Subroutine day_of_quarter_0: called CC=1 SCAR=0.0
Pod undocumented
858 49 *doq_0 = \&day_of_quarter_0;
859  
860 79 ▶sub day_of_year { $_[0]->{local_c}{day_of_year} }
Subroutine day_of_year: called CC=1 SCAR=0.0
Pod documented
861 49 *doy = \&day_of_year;
862  
863 3 ▶sub day_of_year_0 { $_[0]->{local_c}{day_of_year} - 1 }
Subroutine day_of_year_0: called CC=1 SCAR=0.0
Pod undocumented
864 49 *doy_0 = \&day_of_year_0;
865  
866 25 ▶sub am_or_pm {
Subroutine am_or_pm: called CC=2 SCAR=6.9
Pod documented
867 25 ▶ $_[0]->{locale}->am_pm_abbreviated->[ $_[0]->hour < 12 ? 0 : 1 ];
Branch: 1 branch
BranchTrueFalseTotal
$_[0]->hour < 12 ? : 8 17 25
868 }
869  
870 828 ▶sub ymd {
Subroutine ymd: called CC=2 SCAR=6.9
Pod documented
871 828 my ( $self, $sep ) = @_;
872 828 ▶ $sep = '-' unless defined $sep;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $sep 662 166 828
873  
874 return sprintf(
875 '%0.4d%s%0.2d%s%0.2d',
876 $self->year, $sep,
877 $self->{local_c}{month}, $sep,
878 $self->{local_c}{day}
879 828 );
880 }
881 522 ▶*date = sub { shift->ymd(@_) };
Subroutine __ANON__: called CC=1 SCAR=0.0
882  
883 4 ▶sub mdy {
Subroutine mdy: called CC=2 SCAR=6.9
Pod documented
884 4 my ( $self, $sep ) = @_;
885 4 ▶ $sep = '-' unless defined $sep;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $sep 2 2 4
886  
887 return sprintf(
888 '%0.2d%s%0.2d%s%0.4d',
889 $self->{local_c}{month}, $sep,
890 4 $self->{local_c}{day}, $sep,
891 $self->year
892 );
893 }
894  
895 4 ▶sub dmy {
Subroutine dmy: called CC=2 SCAR=6.9
Pod documented
896 4 my ( $self, $sep ) = @_;
897 4 ▶ $sep = '-' unless defined $sep;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $sep 2 2 4
898  
899 return sprintf(
900 '%0.2d%s%0.2d%s%0.4d',
901 $self->{local_c}{day}, $sep,
902 4 $self->{local_c}{month}, $sep,
903 $self->year
904 );
905 }
906  
907 553 ▶sub hour {
Subroutine hour: called CC=2 SCAR=6.9
Pod documented
908 553 ▶ Carp::carp('hour() is a read-only accessor') if @_ > 1;
Branch: 1 branch
BranchTrueFalseTotal
if @_ > 1 1 552 553
909 553 return $_[0]->{local_c}{hour};
910 }
911 7 ▶sub hour_1 { $_[0]->{local_c}{hour} == 0 ? 24 : $_[0]->{local_c}{hour} }
Subroutine hour_1: called CC=2 SCAR=6.9
Pod documented
Branch: 1 branch
BranchTrueFalseTotal
$_[0]{'local_c'}{'hour'} == 0 ? : 1 6 7
912  
913 33 ▶sub hour_12 { my $h = $_[0]->hour % 12; return $h ? $h : 12 }
Subroutine hour_12: called CC=2 SCAR=6.9
Pod documented
Branch: 1 branch
BranchTrueFalseTotal
$h ? : 26 7 33
914 5 ▶sub hour_12_0 { $_[0]->hour % 12 }
Subroutine hour_12_0: called CC=1 SCAR=0.0
Pod documented
915  
916 503 ▶sub minute {
Subroutine minute: called CC=2 SCAR=6.9
Pod documented
917 503 ▶ Carp::carp('minute() is a read-only accessor') if @_ > 1;
Branch: 1 branch
BranchTrueFalseTotal
if @_ > 1 1 502 503
918 503 return $_[0]->{local_c}{minute};
919 }
920 49 *min = \&minute;
921  
922 63779 ▶sub second {
Subroutine second: called CC=2 SCAR=6.9
Pod documented
923 63779 ▶ Carp::carp('second() is a read-only accessor') if @_ > 1;
Branch: 1 branch
BranchTrueFalseTotal
if @_ > 1 1 63778 63779
924 63779 return $_[0]->{local_c}{second};
925 }
926 49 *sec = \&second;
927  
928 3 ▶sub fractional_second { $_[0]->second + $_[0]->nanosecond / MAX_NANOSECONDS }
Subroutine fractional_second: called CC=1 SCAR=0.0
Pod documented
929  
930 470 ▶sub nanosecond {
Subroutine nanosecond: called CC=2 SCAR=6.9
Pod documented
931 470 ▶ Carp::carp('nanosecond() is a read-only accessor') if @_ > 1;
Branch: 1 branch
BranchTrueFalseTotal
if @_ > 1 1 469 470
932 470 return $_[0]->{rd_nanosecs};
933 }
934  
935 10 ▶sub millisecond { floor( $_[0]->{rd_nanosecs} / 1000000 ) }
Subroutine millisecond: called CC=1 SCAR=0.0
Pod documented
936  
937 9 ▶sub microsecond { floor( $_[0]->{rd_nanosecs} / 1000 ) }
Subroutine microsecond: called CC=1 SCAR=0.0
Pod documented
938  
939 3 ▶sub leap_seconds {
Subroutine leap_seconds: called CC=2 SCAR=6.9
Pod documented
940 3 my $self = shift;
941  
942 3 ▶ return 0 if $self->{tz}->is_floating;
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"tz"}->is_floating 1 2 3
943  
944 2 return $self->_accumulated_leap_seconds( $self->{utc_rd_days} );
945 }
946  
947 36 ▶sub stringify {
Subroutine stringify: called CC=2 SCAR=6.9
Pod documented
948 36 my $self = shift;
949  
950 36 ▶ return $self->iso8601 unless $self->{formatter};
Branch: 1 branch
BranchTrueFalseTotal
unless $self->{"formatter"} 31 5 36
951 5 return $self->{formatter}->format_datetime($self);
952 }
953  
954 168 ▶sub hms {
Subroutine hms: called CC=2 SCAR=6.9
Pod documented
955 168 my ( $self, $sep ) = @_;
956 168 ▶ $sep = ':' unless defined $sep;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $sep 2 166 168
957  
958 return sprintf(
959 '%0.2d%s%0.2d%s%0.2d',
960 $self->{local_c}{hour}, $sep,
961 $self->{local_c}{minute}, $sep,
962 $self->{local_c}{second}
963 168 );
964 }
965  
966 # don't want to override CORE::time()
967 4 ▶*DateTime::time = sub { shift->hms(@_) };
Subroutine __ANON__: called CC=1 SCAR=0.0
968  
969 52 ▶sub iso8601 { $_[0]->datetime('T') }
Subroutine iso8601: called CC=1 SCAR=0.0
Pod undocumented
970  
971 4 ▶sub rfc3339 {
Subroutine rfc3339: called CC=3 SCAR=11.0
Pod documented
972 4 my $self = shift;
973  
974 return $self->datetime('T')
975 4 ▶ if $self->{tz}->is_floating;
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"tz"}->is_floating 1 3 4
976  
977 3 my $secs = $self->offset;
978 3 ▶ my $offset
Branch: 1 branch
BranchTrueFalseTotal
$secs ? : 2 1 3
979 = $secs
980 ? DateTime::TimeZone->offset_as_string( $secs, q{:} )
981 : 'Z';
982  
983 3 return $self->datetime('T') . $offset;
984 }
985  
986 163 ▶sub datetime {
Subroutine datetime: called CC=2 SCAR=6.9
Pod documented
987 163 my ( $self, $sep ) = @_;
988 163 ▶ $sep = 'T' unless defined $sep;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $sep 118 45 163
989 163 return join $sep, $self->ymd('-'), $self->hms(':');
990 }
991  
992 2 ▶sub is_leap_year { $_[0]->_is_leap_year( $_[0]->year ) }
Subroutine is_leap_year: called CC=1 SCAR=0.0
Pod documented
993  
994 3 ▶sub month_length {
Subroutine month_length: called CC=1 SCAR=0.0
Pod documented
995 3 $_[0]->_month_length( $_[0]->year, $_[0]->month );
996 }
997  
998 15 ▶sub quarter_length {
Subroutine quarter_length: called CC=2 SCAR=6.9
Pod documented
999 return (
1000 15 ▶ $_[0]->_is_leap_year( $_[0]->year )
Branch: 1 branch
BranchTrueFalseTotal
$_[0]->_is_leap_year($_[0]->year) ? : 4 11 15
1001 ? $LeapYearQuarterLengths[ $_[0]->quarter - 1 ]
1002 : $QuarterLengths[ $_[0]->quarter - 1 ]
1003 );
1004 }
1005  
1006 5 ▶sub year_length {
Subroutine year_length: called CC=2 SCAR=6.9
Pod documented
1007 5 ▶ $_[0]->_is_leap_year( $_[0]->year ) ? 366 : 365;
Branch: 1 branch
BranchTrueFalseTotal
$_[0]->_is_leap_year($_[0]->year) ? : 1 4 5
1008 }
1009  
1010 5 ▶sub is_last_day_of_month {
Subroutine is_last_day_of_month: called CC=1 SCAR=0.0
Pod documented
1011 5 $_[0]->day == $_[0]->_month_length( $_[0]->year, $_[0]->month );
1012 }
1013  
1014 6 ▶sub is_last_day_of_quarter {
Subroutine is_last_day_of_quarter: called CC=1 SCAR=0.0
Pod documented
1015 6 $_[0]->day_of_quarter == $_[0]->quarter_length;
1016 }
1017  
1018 3 ▶sub is_last_day_of_year {
Subroutine is_last_day_of_year: called CC=1 SCAR=0.0
Pod documented
1019 3 $_[0]->day_of_year == $_[0]->year_length;
1020 }
1021  
1022 45 ▶sub week {
Subroutine week: called CC=2 SCAR=7.0
Pod documented
1023 45 my $self = shift;
1024  
1025 45 ▶ $self->{utc_c}{week_year} ||= $self->_week_values;
Condition66%2/3
$self->{"utc_c"}{"week_year"} ||= $self->_week_values
l!l&&r!l&&!r
12330
MC/DC0%0/2
$self->{"utc_c"}{"week_year"} ||= $self->_week_values
$self->{"utc_c"}{"week_year"} $self->_week_values
Truth table66%2/3
A ||= B
A= $self->{"utc_c"}{"week_year"}B= $self->_week_values
ABresult
1X1
011
000
1026  
1027 45 return @{ $self->{utc_c}{week_year} }[ 0, 1 ];
1028 }
1029  
1030 # This algorithm comes from
1031 # https://en.wikipedia.org/wiki/ISO_week_date#Calculating_the_week_number_of_a_given_date
1032 31 ▶sub _week_values {
Subroutine _week_values: called CC=4 SCAR=13.9
1033 31 my $self = shift;
1034  
1035 31 my $week
1036 = int( ( ( $self->day_of_year - $self->day_of_week ) + 10 ) / 7 );
1037  
1038 31 my $year = $self->year;
1039 31 ▶ if ( $week == 0 ) {
Branch: 2 branches
BranchTrueFalseTotal
if ($week == 0) { } 4 27 31
elsif ($week == 53 and $self->_weeks_in_year($year) == 52) { } 5 42 47
1040 4 $year--;
1041 4 return [ $year, $self->_weeks_in_year($year) ];
1042 }
1043 ▶ elsif ( $week == 53 && $self->_weeks_in_year($year) == 52 ) {
Condition100%3/3
$week == 53 and $self->_weeks_in_year($year) == 52
!ll&&!rl&&r
2025
MC/DC100%2/2
$week == 53 and $self->_weeks_in_year($year) == 52
$week == 53 $self->_weeks_in_year($year) == 52
Truth table100%3/3
A and B
A= $week == 53B= $self->_weeks_in_year($year) == 52
ABresult
0X0
100
111
1044 5 return [ $year + 1, 1 ];
1045 }
1046  
1047 22 return [ $year, $week ];
1048 }
1049  
1050 11 ▶sub _weeks_in_year {
Subroutine _weeks_in_year: called CC=4 SCAR=13.9
1051 11 my $self = shift;
1052 11 my $year = shift;
1053  
1054 11 my $dow = $self->_ymd2rd( $year, 1, 1 ) % 7;
1055  
1056 # Years starting with a Thursday and leap years starting with a Wednesday
1057 # have 53 weeks.
1058 11 ▶ return ( $dow == 4 || ( $dow == 3 && $self->_is_leap_year($year) ) )
Branch: 1 branch
BranchTrueFalseTotal
$dow == 4 || $dow == 3 && $self->_is_leap_year($year) ? : 4 7 11
Condition100%6/6
$dow == 4 or $dow == 3 and $self->_is_leap_year($year)
l!l&&r!l&&!r
227
$dow == 3 and $self->_is_leap_year($year)
!ll&&!rl&&r
612
MC/DC100%3/3
$dow == 4 or $dow == 3 and $self->_is_leap_year($year)
$dow == 4 $dow == 3 $self->_is_leap_year($year)
Truth table100%4/4
A or B and C
A= $dow == 4B= $dow == 3C= $self->_is_leap_year($year)
ABCresult
1XX1
0111
00X0
0100
1059 ? 53
1060 : 52;
1061 }
1062  
1063 9 ▶sub week_year { ( $_[0]->week )[0] }
Subroutine week_year: called CC=1 SCAR=0.0
Pod documented
1064 8 ▶sub week_number { ( $_[0]->week )[1] }
Subroutine week_number: called CC=1 SCAR=0.0
Pod documented
1065  
1066 # ISO says that the first week of a year is the first week containing
1067 # a Thursday. Extending that says that the first week of the month is
1068 # the first week containing a Thursday. ICU agrees.
1069 4 ▶sub week_of_month {
Subroutine week_of_month: called CC=1 SCAR=0.0
Pod documented
1070 4 my $self = shift;
1071 4 my $thu = $self->day + 4 - $self->day_of_week;
1072 4 return int( ( $thu + 6 ) / 7 );
1073 }
1074  
1075 82326 ▶sub time_zone {
Subroutine time_zone: called CC=2 SCAR=6.9
Pod documented
1076 82326 ▶ Carp::carp('time_zone() is a read-only accessor') if @_ > 1;
Branch: 1 branch
BranchTrueFalseTotal
if @_ > 1 1 82325 82326
1077 82326 return $_[0]->{tz};
1078 }
1079  
1080 434 ▶sub offset { $_[0]->{tz}->offset_for_datetime( $_[0] ) }
Subroutine offset: called CC=1 SCAR=0.0
Pod documented
1081  
1082 33676 ▶sub _offset_for_local_datetime {
Subroutine _offset_for_local_datetime: called CC=1 SCAR=0.0
1083 33676 $_[0]->{tz}->offset_for_local_datetime( $_[0] );
1084 }
1085  
1086 71 ▶sub is_dst { $_[0]->{tz}->is_dst_for_datetime( $_[0] ) }
Subroutine is_dst: called CC=1 SCAR=0.0
Pod documented
1087  
1088 3 ▶sub time_zone_long_name { $_[0]->{tz}->name }
Subroutine time_zone_long_name: called CC=1 SCAR=0.0
Pod documented
1089 5 ▶sub time_zone_short_name { $_[0]->{tz}->short_name_for_datetime( $_[0] ) }
Subroutine time_zone_short_name: called CC=1 SCAR=0.0
Pod documented
1090  
1091 215 ▶sub locale {
Subroutine locale: called CC=2 SCAR=6.9
Pod documented
1092 215 ▶ Carp::carp('locale() is a read-only accessor') if @_ > 1;
Branch: 1 branch
BranchTrueFalseTotal
if @_ > 1 1 214 215
1093 215 return $_[0]->{locale};
1094 }
1095  
1096 49998 ▶sub utc_rd_values {
Subroutine utc_rd_values: called CC=1 SCAR=0.0
Pod documented
1097 49998 @{ $_[0] }{ 'utc_rd_days', 'utc_rd_secs', 'rd_nanosecs' };
1098 }
1099  
1100 14 ▶sub local_rd_values {
Subroutine local_rd_values: called CC=1 SCAR=0.0
Pod documented
1101 14 @{ $_[0] }{ 'local_rd_days', 'local_rd_secs', 'rd_nanosecs' };
1102 }
1103  
1104 # NOTE: no nanoseconds, no leap seconds
1105 31741 ▶sub utc_rd_as_seconds {
Subroutine utc_rd_as_seconds: called CC=1 SCAR=0.0
Pod documented
1106 31741 ( $_[0]->{utc_rd_days} * SECONDS_PER_DAY ) + $_[0]->{utc_rd_secs};
1107 }
1108  
1109 # NOTE: no nanoseconds, no leap seconds
1110 255 ▶sub local_rd_as_seconds {
Subroutine local_rd_as_seconds: called CC=1 SCAR=0.0
Pod undocumented
1111 255 ( $_[0]->{local_rd_days} * SECONDS_PER_DAY ) + $_[0]->{local_rd_secs};
1112 }
1113  
1114 # RD 1 is MJD 678,576 - a simple offset
1115 28 ▶sub mjd {
Subroutine mjd: called CC=1 SCAR=0.0
Pod documented
1116 28 my $self = shift;
1117  
1118 28 my $mjd = $self->{utc_rd_days} - 678_576;
1119  
1120 28 my $day_length = $self->_day_length( $self->{utc_rd_days} );
1121  
1122 return ( $mjd
1123 + ( $self->{utc_rd_secs} / $day_length )
1124 28 + ( $self->{rd_nanosecs} / $day_length / MAX_NANOSECONDS ) );
1125 }
1126  
1127 16 ▶sub jd { $_[0]->mjd + 2_400_000.5 }
Subroutine jd: called CC=1 SCAR=0.0
Pod documented
1128  
1129 {
1130 my %strftime_patterns = (
1131 3 ▶ 'a' => sub { $_[0]->day_abbr },
Subroutine __ANON__: called CC=1 SCAR=0.0
1132 3 ▶ 'A' => sub { $_[0]->day_name },
Subroutine __ANON__: called CC=1 SCAR=0.0
1133 4 ▶ 'b' => sub { $_[0]->month_abbr },
Subroutine __ANON__: called CC=1 SCAR=0.0
1134 3 ▶ 'B' => sub { $_[0]->month_name },
Subroutine __ANON__: called CC=1 SCAR=0.0
1135 1 ▶ 'c' => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
1136 1 $_[0]->format_cldr( $_[0]->{locale}->datetime_format_default );
1137 },
1138 3 ▶ 'C' => sub { int( $_[0]->year / 100 ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1139 14 ▶ 'd' => sub { sprintf( '%02d', $_[0]->day_of_month ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1140 3 ▶ 'D' => sub { $_[0]->strftime('%m/%d/%y') },
Subroutine __ANON__: called CC=1 SCAR=0.0
1141 3 ▶ 'e' => sub { sprintf( '%2d', $_[0]->day_of_month ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1142 2 ▶ 'F' => sub { $_[0]->strftime('%Y-%m-%d') },
Subroutine __ANON__: called CC=1 SCAR=0.0
1143 1 ▶ 'g' => sub { substr( $_[0]->week_year, -2 ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1144 1 ▶ 'G' => sub { $_[0]->week_year },
Subroutine __ANON__: called CC=1 SCAR=0.0
1145 14 ▶ 'H' => sub { sprintf( '%02d', $_[0]->hour ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1146 13 ▶ 'I' => sub { sprintf( '%02d', $_[0]->hour_12 ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1147 5 ▶ 'j' => sub { sprintf( '%03d', $_[0]->day_of_year ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1148 3 ▶ 'k' => sub { sprintf( '%2d', $_[0]->hour ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1149 10 ▶ 'l' => sub { sprintf( '%2d', $_[0]->hour_12 ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1150 13 ▶ 'm' => sub { sprintf( '%02d', $_[0]->month ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1151 31 ▶ 'M' => sub { sprintf( '%02d', $_[0]->minute ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1152 3 ▶ 'n' => sub {"\n"}, # should this be OS-sensitive?
Subroutine __ANON__: called CC=1 SCAR=0.0
1153 'N' => \&_format_nanosecs,
1154 20 ▶ 'p' => sub { $_[0]->am_or_pm },
Subroutine __ANON__: called CC=1 SCAR=0.0
1155 1 ▶ 'P' => sub { lc $_[0]->am_or_pm },
Subroutine __ANON__: called CC=1 SCAR=0.0
1156 3 ▶ 'r' => sub { $_[0]->strftime('%I:%M:%S %p') },
Subroutine __ANON__: called CC=1 SCAR=0.0
1157 3 ▶ 'R' => sub { $_[0]->strftime('%H:%M') },
Subroutine __ANON__: called CC=1 SCAR=0.0
1158 3 ▶ 's' => sub { $_[0]->epoch },
Subroutine __ANON__: called CC=1 SCAR=0.0
1159 14 ▶ 'S' => sub { sprintf( '%02d', $_[0]->second ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1160 1 ▶ 't' => sub {"\t"},
Subroutine __ANON__: called CC=1 SCAR=0.0
1161 8 ▶ 'T' => sub { $_[0]->strftime('%H:%M:%S') },
Subroutine __ANON__: called CC=1 SCAR=0.0
1162 1 ▶ 'u' => sub { $_[0]->day_of_week },
Subroutine __ANON__: called CC=1 SCAR=0.0
1163 5 ▶ 'U' => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
1164 5 my $sun = $_[0]->day_of_year - ( $_[0]->day_of_week + 7 ) % 7;
1165 5 return sprintf( '%02d', int( ( $sun + 6 ) / 7 ) );
1166 },
1167 4 ▶ 'V' => sub { sprintf( '%02d', $_[0]->week_number ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1168 3 ▶ 'w' => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
1169 3 my $dow = $_[0]->day_of_week;
1170 3 return $dow % 7;
1171 },
1172 5 ▶ 'W' => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
1173 5 my $mon = $_[0]->day_of_year - ( $_[0]->day_of_week + 6 ) % 7;
1174 5 return sprintf( '%02d', int( ( $mon + 6 ) / 7 ) );
1175 },
1176 1 ▶ 'x' => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
1177 1 $_[0]->format_cldr( $_[0]->{locale}->date_format_default );
1178 },
1179 1 ▶ 'X' => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
1180 1 $_[0]->format_cldr( $_[0]->{locale}->time_format_default );
1181 },
1182 6 ▶ 'y' => sub { sprintf( '%02d', substr( $_[0]->year, -2 ) ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1183 12 ▶ 'Y' => sub { return $_[0]->year },
Subroutine __ANON__: called CC=1 SCAR=0.0
1184 3 ▶ 'z' => sub { DateTime::TimeZone->offset_as_string( $_[0]->offset ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1185 3 ▶ 'Z' => sub { $_[0]->{tz}->short_name_for_datetime( $_[0] ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1186 5 ▶ '%' => sub {'%'},
Subroutine __ANON__: called CC=1 SCAR=0.0
1187 49 );
1188  
1189 49 $strftime_patterns{h} = $strftime_patterns{b};
1190  
1191 186 ▶ sub strftime {
Subroutine strftime: called CC=8 SCAR=20.8
Pod documented
1192 186 my $self = shift;
1193  
1194 # make a copy or caller's scalars get munged
1195 186 my @patterns = @_;
1196  
1197 186 my @r;
1198 186 for my $p (@patterns) {
1199 187 $p =~ s/
1200 (?:
1201 %\{(\w+)\} # method name like %{day_name}
1202 |
1203 %([%a-zA-Z]) # single character specifier like %d
1204 |
1205 %(\d+)N # special case for %N
1206 )
1207 /
1208 ( $1
1209 ? ( $self->can($1) ? $self->$1() : "\%{$1}" )
1210 : $2
1211 ? ( $strftime_patterns{$2} ? $strftime_patterns{$2}->($self) : "\%$2" )
1212 : $3
1213 270 ▶ ? $strftime_patterns{N}->($self, $3)
Branch: 5 branches
BranchTrueFalseTotal
$1 ? : 7 263 270
$self->can($1) ? : 6 1 7
$2 ? : 238 25 263
$strftime_patterns{$2} ? : 237 1 238
$3 ? : 25 0 25
1214 : '' # this won't happen
1215 )
1216 /sgex;
1217  
1218 187 ▶ return $p unless wantarray;
Branch: 1 branch
BranchTrueFalseTotal
unless wantarray 185 2 187
1219  
1220 2 push @r, $p;
1221 }
1222  
1223 1 return @r;
1224 }
1225 }
1226  
1227 {
1228  
1229 # It's an array because the order in which the regexes are checked
1230 # is important. These patterns are similar to the ones Java uses,
1231 # but not quite the same. See
1232 # http://www.unicode.org/reports/tr35/tr35-9.html#Date_Format_Patterns.
1233 49 my @patterns = (
1234 qr/GGGGG/ =>
1235 1 ▶ sub { $_[0]->{locale}->era_narrow->[ $_[0]->_era_index ] },
Subroutine __ANON__: called CC=1 SCAR=0.0
1236 qr/GGGG/ => 'era_name',
1237 qr/G{1,3}/ => 'era_abbr',
1238  
1239 13 ▶ qr/(y{3,5})/ => sub { $_[0]->_zero_padded_number( $1, $_[0]->year ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1240  
1241 # yy is a weird special case, where it must be exactly 2 digits
1242 4 ▶ qr/yy/ => sub {
Subroutine __ANON__: called CC=3 SCAR=11.0
1243 4 my $year = $_[0]->year;
1244 4 ▶ my $y2 = length $year > 2 ? substr( $year, -2, 2 ) : $year;
Branch: 1 branch
BranchTrueFalseTotal
length $year > 2 ? : 4 0 4
1245 4 ▶ $y2 *= -1 if $year < 0;
Branch: 1 branch
BranchTrueFalseTotal
if $year < 0 2 2 4
1246 4 $_[0]->_zero_padded_number( 'yy', $y2 );
1247 },
1248 qr/y/ => 'year',
1249 16 ▶ qr/(u+)/ => sub { $_[0]->_zero_padded_number( $1, $_[0]->year ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1250 qr/(Y+)/ =>
1251 5 ▶ sub { $_[0]->_zero_padded_number( $1, $_[0]->week_year ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1252  
1253 qr/QQQQ/ => 'quarter_name',
1254 qr/QQQ/ => 'quarter_abbr',
1255 2 ▶ qr/(QQ?)/ => sub { $_[0]->_zero_padded_number( $1, $_[0]->quarter ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1256  
1257 1 ▶ qr/qqqq/ => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
1258 1 $_[0]->{locale}->quarter_stand_alone_wide->[ $_[0]->quarter_0 ];
1259 },
1260 1 ▶ qr/qqq/ => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
1261 $_[0]->{locale}
1262 1 ->quarter_stand_alone_abbreviated->[ $_[0]->quarter_0 ];
1263 },
1264 2 ▶ qr/(qq?)/ => sub { $_[0]->_zero_padded_number( $1, $_[0]->quarter ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1265  
1266 qr/MMMMM/ =>
1267 1 ▶ sub { $_[0]->{locale}->month_format_narrow->[ $_[0]->month_0 ] },
Subroutine __ANON__: called CC=1 SCAR=0.0
1268 qr/MMMM/ => 'month_name',
1269 qr/MMM/ => 'month_abbr',
1270 4 ▶ qr/(MM?)/ => sub { $_[0]->_zero_padded_number( $1, $_[0]->month ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1271  
1272 1 ▶ qr/LLLLL/ => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
1273 1 $_[0]->{locale}->month_stand_alone_narrow->[ $_[0]->month_0 ];
1274 },
1275 1 ▶ qr/LLLL/ => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
1276 1 $_[0]->{locale}->month_stand_alone_wide->[ $_[0]->month_0 ];
1277 },
1278 1 ▶ qr/LLL/ => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
1279 $_[0]->{locale}
1280 1 ->month_stand_alone_abbreviated->[ $_[0]->month_0 ];
1281 },
1282 2 ▶ qr/(LL?)/ => sub { $_[0]->_zero_padded_number( $1, $_[0]->month ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1283  
1284 qr/(ww?)/ =>
1285 2 ▶ sub { $_[0]->_zero_padded_number( $1, $_[0]->week_number ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1286 qr/W/ => 'week_of_month',
1287  
1288 # Locale objects that subclass DateTime::Locale::Base don't have this method, and locales
1289 # registered with custom data may not have this data, so we fall back to the plain day
1290 # number.
1291 3 ▶ qr/ddd/ => sub {
Subroutine __ANON__: called CC=4 SCAR=13.9
1292 my $days
1293 = $_[0]->{locale}->can('day_of_month_format_abbreviated')
1294 ? $_[0]->{locale}->day_of_month_format_abbreviated
1295 3 ▶ : undef;
Branch: 1 branch
BranchTrueFalseTotal
$_[0]{'locale'}->can('day_of_month_format_abbreviated') ? : 3 0 3
1296 3 ▶ my $day = $days ? $days->[ $_[0]->day_of_month_0 ] : undef;
Branch: 1 branch
BranchTrueFalseTotal
$days ? : 2 1 3
1297 3 ▶ return defined $day ? $day : $_[0]->day_of_month;
Branch: 1 branch
BranchTrueFalseTotal
defined $day ? : 2 1 3
1298 },
1299 qr/(dd?)/ =>
1300 7 ▶ sub { $_[0]->_zero_padded_number( $1, $_[0]->day_of_month ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1301 qr/(D{1,3})/ =>
1302 3 ▶ sub { $_[0]->_zero_padded_number( $1, $_[0]->day_of_year ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1303  
1304 qr/F/ => 'weekday_of_month',
1305 2 ▶ qr/(g+)/ => sub { $_[0]->_zero_padded_number( $1, $_[0]->mjd ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1306  
1307 1 ▶ qr/EEEEE/ => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
1308 1 $_[0]->{locale}->day_format_narrow->[ $_[0]->day_of_week_0 ];
1309 },
1310 qr/EEEE/ => 'day_name',
1311 qr/E{1,3}/ => 'day_abbr',
1312  
1313 1 ▶ qr/eeeee/ => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
1314 1 $_[0]->{locale}->day_format_narrow->[ $_[0]->day_of_week_0 ];
1315 },
1316 qr/eeee/ => 'day_name',
1317 qr/eee/ => 'day_abbr',
1318 4 ▶ qr/(ee?)/ => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
1319 4 $_[0]->_zero_padded_number( $1, $_[0]->local_day_of_week );
1320 },
1321  
1322 1 ▶ qr/ccccc/ => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
1323 1 $_[0]->{locale}->day_stand_alone_narrow->[ $_[0]->day_of_week_0 ];
1324 },
1325 1 ▶ qr/cccc/ => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
1326 1 $_[0]->{locale}->day_stand_alone_wide->[ $_[0]->day_of_week_0 ];
1327 },
1328 1 ▶ qr/ccc/ => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
1329 $_[0]->{locale}
1330 1 ->day_stand_alone_abbreviated->[ $_[0]->day_of_week_0 ];
1331 },
1332 qr/(cc?)/ =>
1333 4 ▶ sub { $_[0]->_zero_padded_number( $1, $_[0]->day_of_week ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1334  
1335 qr/a/ => 'am_or_pm',
1336  
1337 4 ▶ qr/(hh?)/ => sub { $_[0]->_zero_padded_number( $1, $_[0]->hour_12 ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1338 2 ▶ qr/(HH?)/ => sub { $_[0]->_zero_padded_number( $1, $_[0]->hour ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1339 qr/(KK?)/ =>
1340 2 ▶ sub { $_[0]->_zero_padded_number( $1, $_[0]->hour_12_0 ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1341 1 ▶ qr/(kk?)/ => sub { $_[0]->_zero_padded_number( $1, $_[0]->hour_1 ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1342 4 ▶ qr/(jj?)/ => sub {
Subroutine __ANON__: called CC=2 SCAR=6.9
1343 my $h
1344 = $_[0]->{locale}->prefers_24_hour_time
1345 4 ▶ ? $_[0]->hour
Branch: 1 branch
BranchTrueFalseTotal
$_[0]{'locale'}->prefers_24_hour_time ? : 1 3 4
1346 : $_[0]->hour_12;
1347 4 $_[0]->_zero_padded_number( $1, $h );
1348 },
1349  
1350 4 ▶ qr/(mm?)/ => sub { $_[0]->_zero_padded_number( $1, $_[0]->minute ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1351  
1352 5 ▶ qr/(ss?)/ => sub { $_[0]->_zero_padded_number( $1, $_[0]->second ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1353  
1354 # The LDML spec is not 100% clear on how to truncate this field, but
1355 # this way seems as good as anything.
1356 4 ▶ qr/(S+)/ => sub { $_[0]->_format_nanosecs( length($1) ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1357 qr/A+/ =>
1358 1 ▶ sub { ( $_[0]->{local_rd_secs} * 1000 ) + $_[0]->millisecond },
Subroutine __ANON__: called CC=1 SCAR=0.0
1359  
1360 qr/zzzz/ => 'time_zone_long_name',
1361 qr/z{1,3}/ => 'time_zone_short_name',
1362 1 ▶ qr/ZZZZZ/ => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
1363 1 DateTime::TimeZone->offset_as_string( $_[0]->offset, q{:} );
1364 },
1365 1 ▶ qr/ZZZZ/ => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
1366 1 $_[0]->time_zone_short_name
1367 . DateTime::TimeZone->offset_as_string( $_[0]->offset );
1368 },
1369 qr/Z{1,3}/ =>
1370 1 ▶ sub { DateTime::TimeZone->offset_as_string( $_[0]->offset ) },
Subroutine __ANON__: called CC=1 SCAR=0.0
1371 49 qr/vvvv/ => 'time_zone_long_name',
1372 qr/v{1,3}/ => 'time_zone_short_name',
1373 qr/VVVV/ => 'time_zone_long_name',
1374 qr/V{1,3}/ => 'time_zone_short_name',
1375 );
1376  
1377 92 ▶ sub _zero_padded_number {
Subroutine _zero_padded_number: called CC=1 SCAR=0.0
1378 92 my $self = shift;
1379 92 my $size = length shift;
1380 92 my $val = shift;
1381  
1382 92 return sprintf( "%0${size}d", $val );
1383 }
1384  
1385 132 ▶ sub format_cldr {
Subroutine format_cldr: called CC=6 SCAR=18.6
Pod documented
1386 132 my $self = shift;
1387  
1388 # make a copy or caller's scalars get munged
1389 132 my @p = @_;
1390  
1391 132 my @r;
1392 132 for my $p (@p) {
1393 132 $p =~ s/\G
1394 (?:
1395 '((?:[^']|'')*)' # quote escaped bit of text
1396 # it needs to end with one
1397 # quote not followed by
1398 # another
1399 |
1400 (([a-zA-Z])\3*) # could be a pattern
1401 |
1402 (.) # anything else
1403 )
1404 /
1405 176 ▶ defined $1
Branch: 3 branches
BranchTrueFalseTotal
defined $1 ? : 4 172 176
defined $2 ? : 148 24 172
defined $4 ? : 24 0 24
1406 ? $1
1407 : defined $2
1408 ? $self->_cldr_pattern($2)
1409 : defined $4
1410 ? $4
1411 : undef # should never get here
1412 /sgex;
1413  
1414 132 $p =~ s/\'\'/\'/g;
1415  
1416 132 ▶ return $p unless wantarray;
Branch: 1 branch
BranchTrueFalseTotal
unless wantarray 132 0 132
1417  
1418 0 push @r, $p;
1419 }
1420  
1421 0 return @r;
1422 }
1423  
1424 148 ▶ sub _cldr_pattern {
Subroutine _cldr_pattern: called CC=3 SCAR=11.2
1425 148 my $self = shift;
1426 148 my $pattern = shift;
1427  
1428 ## no critic (ControlStructures::ProhibitCStyleForLoops)
1429 148 ▶ for ( my $i = 0; $i < @patterns; $i += 2 ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($i < @patterns) 3668 0 3668
1430 3668 ▶ if ( $pattern =~ /$patterns[$i]/ ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pattern =~ /$patterns[$i]/) 148 3520 3668
1431 148 my $sub = $patterns[ $i + 1 ];
1432  
1433 148 return $self->$sub();
1434 }
1435 }
1436  
1437 0 return $pattern;
1438 }
1439 }
1440  
1441 49 ▶sub _format_nanosecs {
Subroutine _format_nanosecs: called CC=3 SCAR=11.0
1442 31 my $self = shift;
1443 31 ▶ my $precision = @_ ? shift : 9;
Branch: 1 branch
BranchTrueFalseTotal
@_ ? : 29 2 31
1444  
1445 31 my $exponent = 9 - $precision;
1446 my $formatted_ns = floor(
1447 (
1448 $exponent < 0
1449 ? $self->{rd_nanosecs} * 10**-$exponent
1450 31 ▶ : $self->{rd_nanosecs} / 10**$exponent
Branch: 1 branch
BranchTrueFalseTotal
$exponent < 0 ? : 4 27 31
1451 )
1452 );
1453  
1454 31 return sprintf(
1455 '%0' . $precision . 'u',
1456 $formatted_ns
1457 );
1458 }
1459  
1460 29 ▶sub epoch {
Subroutine epoch: called CC=2 SCAR=6.9
Pod documented
1461 29 my $self = shift;
1462  
1463 return $self->{utc_c}{epoch}
1464 29 ▶ if exists $self->{utc_c}{epoch};
Branch: 1 branch
BranchTrueFalseTotal
if exists $self->{"utc_c"}{"epoch"} 2 27 29
1465  
1466 return $self->{utc_c}{epoch}
1467 = ( $self->{utc_rd_days} - 719163 ) * SECONDS_PER_DAY
1468 27 + $self->{utc_rd_secs};
1469 }
1470  
1471 2 ▶sub hires_epoch {
Subroutine hires_epoch: called CC=2 SCAR=7.0
Pod documented
1472 2 my $self = shift;
1473  
1474 2 my $epoch = $self->epoch;
1475  
1476 2 ▶ return undef unless defined $epoch;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $epoch 0 2 2
1477  
1478 2 my $nano = $self->{rd_nanosecs} / MAX_NANOSECONDS;
1479  
1480 2 return $epoch + $nano;
1481 }
1482  
1483 0 ▶sub is_finite {1}
Subroutine is_finite: not called CC=1 SCAR=6.9
Pod documented
1484 31922 ▶sub is_infinite {0}
Subroutine is_infinite: called CC=1 SCAR=0.0
Pod documented
1485  
1486 # added for benefit of DateTime::TimeZone
1487 10 ▶sub utc_year { $_[0]->{utc_year} }
Subroutine utc_year: called CC=1 SCAR=0.0
Pod undocumented
1488  
1489 # returns a result that is relative to the first datetime
1490 55 ▶sub subtract_datetime {
Subroutine subtract_datetime: called CC=20 SCAR=30.0
Pod documented
1491 55 my $dt1 = shift;
1492 55 my $dt2 = shift;
1493  
1494 55 ▶ $dt2 = $dt2->clone->set_time_zone( $dt1->time_zone )
Branch: 1 branch
BranchTrueFalseTotal
unless $dt1->time_zone eq $dt2->time_zone 4 51 55
1495 unless $dt1->time_zone eq $dt2->time_zone;
1496  
1497 # We only want a negative duration if $dt2 > $dt1 ($self)
1498 55 ▶ my ( $bigger, $smaller, $negative ) = (
Branch: 1 branch
BranchTrueFalseTotal
$dt1 >= $dt2 ? : 39 16 55
1499 $dt1 >= $dt2
1500 ? ( $dt1, $dt2, 0 )
1501 : ( $dt2, $dt1, 1 )
1502 );
1503  
1504 55 ▶ my $is_floating = $dt1->time_zone->is_floating
Condition66%2/3
$dt1->time_zone->is_floating && $dt2->time_zone->is_floating
!ll&&!rl&&r
43012
MC/DC50%1/2
$dt1->time_zone->is_floating && $dt2->time_zone->is_floating
$dt1->time_zone->is_floating $dt2->time_zone->is_floating
Truth table66%2/3
A && B
A= $dt1->time_zone->is_floatingB= $dt2->time_zone->is_floating
ABresult
0X0
100
111
1505 && $dt2->time_zone->is_floating;
1506  
1507 55 my $minute_length = 60;
1508 55 ▶ unless ($is_floating) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($is_floating) 43 12 55
1509 43 my ( $utc_rd_days, $utc_rd_secs ) = $smaller->utc_rd_values;
1510  
1511 43 ▶ if ( $utc_rd_secs >= 86340 && !$is_floating ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($utc_rd_secs >= 86340 and not $is_floating) 5 38 43
Condition66%2/3
$utc_rd_secs >= 86340 and not $is_floating
!ll&&!rl&&r
3805
MC/DC50%1/2
$utc_rd_secs >= 86340 and not $is_floating
$utc_rd_secs >= 86340 not $is_floating
Truth table66%2/3
A and not(B)
A= $utc_rd_secs >= 86340B= not $is_floating
ABresult
0X0
100
111
1512  
1513 # If the smaller of the two datetimes occurs in the last
1514 # UTC minute of the UTC day, then that minute may not be
1515 # 60 seconds long. If we need to subtract a minute from
1516 # the larger datetime's minutes count in order to adjust
1517 # the seconds difference to be positive, we need to know
1518 # how long that minute was. If one of the datetimes is
1519 # floating, we just assume a minute is 60 seconds.
1520  
1521 5 $minute_length = $dt1->_day_length($utc_rd_days) - 86340;
1522 }
1523 }
1524  
1525 # This is a gross hack that basically figures out if the bigger of
1526 # the two datetimes is the day of a DST change. If it's a 23 hour
1527 # day (switching _to_ DST) then we subtract 60 minutes from the
1528 # local time. If it's a 25 hour day then we add 60 minutes to the
1529 # local time.
1530 #
1531 # This produces the most "intuitive" results, though there are
1532 # still reversibility problems with the resultant duration.
1533 #
1534 # However, if the two objects are on the same (local) date, and we
1535 # are not crossing a DST change, we don't want to invoke the hack
1536 # - see 38local-subtract.t
1537 55 my $bigger_min = $bigger->hour * 60 + $bigger->minute;
1538 55 ▶ if ( $bigger->time_zone->has_dst_changes
Branch: 1 branch
BranchTrueFalseTotal
if ($bigger->time_zone->has_dst_changes and $bigger->is_dst != $smaller->is_dst) 11 44 55
Condition100%3/3
$bigger->time_zone->has_dst_changes and $bigger->is_dst != $smaller->is_dst
!ll&&!rl&&r
36811
MC/DC100%2/2
$bigger->time_zone->has_dst_changes and $bigger->is_dst != $smaller->is_dst
$bigger->time_zone->has_dst_changes $bigger->is_dst != $smaller->is_dst
Truth table100%3/3
A and B
A= $bigger->time_zone->has_dst_changesB= $bigger->is_dst != $smaller->is_dst
ABresult
0X0
100
111
1539 && $bigger->is_dst != $smaller->is_dst ) {
1540  
1541 $bigger_min -= 60
1542  
1543 # it's a 23 hour (local) day
1544 if (
1545 $bigger->is_dst
1546 11 ▶ && do {
Branch: 1 branch
BranchTrueFalseTotal
if $bigger->is_dst and do { my $prev_day = &try(sub { $bigger->clone->subtract("days", 1); } ); $prev_day && !$prev_day->is_dst ? 1 : 0 } 4 7 11
Condition100%3/3
$bigger->is_dst and do { my $prev_day = &try(sub { $bigger->clone->subtract("days", 1); } ); $prev_day && !$prev_day->is_dst ? 1 : 0 }
!ll&&!rl&&r
614
MC/DC100%2/2
$bigger->is_dst and do { my $prev_day = &try(sub { $bigger->clone->subtract("days", 1); } ); $prev_day && !$prev_day->is_dst ? 1 : 0 }
$bigger->is_dst do { my $prev_day = &try(sub { $bigger->clone->subtract("days", 1); } ); $prev_day && !$prev_day->is_dst ? 1 : 0 }
Truth table100%3/3
A and B
A= $bigger->is_dstB= do { my $prev_day = &try(sub { $bigger->clone->subtract("days", 1); } ); $prev_day && !$prev_day->is_dst ? 1 : 0 }
ABresult
0X0
100
111
1547 5 ▶ my $prev_day = try { $bigger->clone->subtract( days => 1 ) };
Subroutine __ANON__: called CC=1 SCAR=0.0
1548 5 ▶ $prev_day && !$prev_day->is_dst ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
$prev_day && !$prev_day->is_dst ? : 4 1 5
Condition66%2/3
$prev_day and not $prev_day->is_dst
!ll&&!rl&&r
104
MC/DC50%1/2
$prev_day and not $prev_day->is_dst
$prev_day not $prev_day->is_dst
Truth table66%2/3
A and not(B)
A= $prev_dayB= not $prev_day->is_dst
ABresult
0X0
100
111
1549 }
1550 );
1551  
1552 $bigger_min += 60
1553  
1554 # it's a 25 hour (local) day
1555 if (
1556 !$bigger->is_dst
1557 11 ▶ && do {
Branch: 1 branch
BranchTrueFalseTotal
if not $bigger->is_dst and do { my $prev_day = &try(sub { $bigger->clone->subtract("days", 1); } ); $prev_day && $prev_day->is_dst ? 1 : 0 } 1 10 11
Condition100%3/3
not $bigger->is_dst and do { my $prev_day = &try(sub { $bigger->clone->subtract("days", 1); } ); $prev_day && $prev_day->is_dst ? 1 : 0 }
!ll&&!rl&&r
551
MC/DC100%2/2
not $bigger->is_dst and do { my $prev_day = &try(sub { $bigger->clone->subtract("days", 1); } ); $prev_day && $prev_day->is_dst ? 1 : 0 }
not $bigger->is_dst do { my $prev_day = &try(sub { $bigger->clone->subtract("days", 1); } ); $prev_day && $prev_day->is_dst ? 1 : 0 }
Truth table100%3/3
not(A) and B
A= not $bigger->is_dstB= do { my $prev_day = &try(sub { $bigger->clone->subtract("days", 1); } ); $prev_day && $prev_day->is_dst ? 1 : 0 }
ABresult
0X0
100
111
1558 6 ▶ my $prev_day = try { $bigger->clone->subtract( days => 1 ) };
Subroutine __ANON__: called CC=1 SCAR=0.0
1559 6 ▶ $prev_day && $prev_day->is_dst ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
$prev_day && $prev_day->is_dst ? : 1 5 6
Condition66%2/3
$prev_day and $prev_day->is_dst
!ll&&!rl&&r
051
MC/DC50%1/2
$prev_day and $prev_day->is_dst
$prev_day $prev_day->is_dst
Truth table66%2/3
A and B
A= $prev_dayB= $prev_day->is_dst
ABresult
0X0
100
111
1560 }
1561 );
1562 }
1563  
1564 55 my ( $months, $days, $minutes, $seconds, $nanoseconds )
1565 = $dt1->_adjust_for_positive_difference(
1566 $bigger->year * 12 + $bigger->month,
1567 $smaller->year * 12 + $smaller->month,
1568  
1569 $bigger->day, $smaller->day,
1570  
1571 $bigger_min, $smaller->hour * 60 + $smaller->minute,
1572  
1573 $bigger->second, $smaller->second,
1574  
1575 $bigger->nanosecond, $smaller->nanosecond,
1576  
1577 $minute_length,
1578  
1579 # XXX - using the smaller as the month length is
1580 # somewhat arbitrary, we could also use the bigger -
1581 # either way we have reversibility problems
1582 $dt1->_month_length( $smaller->year, $smaller->month ),
1583 );
1584  
1585 55 ▶ if ($negative) {
Branch: 1 branch
BranchTrueFalseTotal
if ($negative) 16 39 55
1586 16 for ( $months, $days, $minutes, $seconds, $nanoseconds ) {
1587  
1588 # Some versions of Perl can end up with -0 if we do "0 * -1"!!
1589 80 ▶ $_ *= -1 if $_;
Branch: 1 branch
BranchTrueFalseTotal
if $_ 30 50 80
1590 }
1591 }
1592  
1593 55 return $dt1->duration_class->new(
1594 months => $months,
1595 days => $days,
1596 minutes => $minutes,
1597 seconds => $seconds,
1598 nanoseconds => $nanoseconds,
1599 );
1600 }
1601  
1602 ## no critic (Subroutines::ProhibitManyArgs)
1603 59 ▶sub _adjust_for_positive_difference {
Subroutine _adjust_for_positive_difference: called CC=5 SCAR=16.1
1604 my (
1605 59 $self,
1606 $month1, $month2,
1607 $day1, $day2,
1608 $min1, $min2,
1609 $sec1, $sec2,
1610 $nano1, $nano2,
1611 $minute_length,
1612 $month_length,
1613 ) = @_;
1614  
1615 59 ▶ if ( $nano1 < $nano2 ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($nano1 < $nano2) 7 52 59
1616 7 $sec1--;
1617 7 $nano1 += MAX_NANOSECONDS;
1618 }
1619  
1620 59 ▶ if ( $sec1 < $sec2 ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($sec1 < $sec2) 8 51 59
1621 8 $min1--;
1622 8 $sec1 += $minute_length;
1623 }
1624  
1625 # A day always has 24 * 60 minutes, though the minutes may vary in
1626 # length.
1627 59 ▶ if ( $min1 < $min2 ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($min1 < $min2) 11 48 59
1628 11 $day1--;
1629 11 $min1 += 24 * 60;
1630 }
1631  
1632 59 ▶ if ( $day1 < $day2 ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($day1 < $day2) 12 47 59
1633 12 $month1--;
1634 12 $day1 += $month_length;
1635 }
1636  
1637 return (
1638 59 $month1 - $month2,
1639 $day1 - $day2,
1640 $min1 - $min2,
1641 $sec1 - $sec2,
1642 $nano1 - $nano2,
1643 );
1644 }
1645  
1646 8 ▶sub subtract_datetime_absolute {
Subroutine subtract_datetime_absolute: called CC=4 SCAR=13.9
Pod documented
1647 8 my $self = shift;
1648 8 my $dt = shift;
1649  
1650 8 my $utc_rd_secs1 = $self->utc_rd_as_seconds;
1651 $utc_rd_secs1 += $self->_accumulated_leap_seconds( $self->{utc_rd_days} )
1652 8 ▶ if !$self->time_zone->is_floating;
Branch: 1 branch
BranchTrueFalseTotal
unless $self->time_zone->is_floating 6 2 8
1653  
1654 8 my $utc_rd_secs2 = $dt->utc_rd_as_seconds;
1655 $utc_rd_secs2 += $self->_accumulated_leap_seconds( $dt->{utc_rd_days} )
1656 8 ▶ if !$dt->time_zone->is_floating;
Branch: 1 branch
BranchTrueFalseTotal
unless $dt->time_zone->is_floating 6 2 8
1657  
1658 8 my $seconds = $utc_rd_secs1 - $utc_rd_secs2;
1659 8 my $nanoseconds = $self->nanosecond - $dt->nanosecond;
1660  
1661 8 ▶ if ( $nanoseconds < 0 ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($nanoseconds < 0) 1 7 8
1662 1 $seconds--;
1663 1 $nanoseconds += MAX_NANOSECONDS;
1664 }
1665  
1666 8 return $self->duration_class->new(
1667 seconds => $seconds,
1668 nanoseconds => $nanoseconds,
1669 );
1670 }
1671  
1672 4 ▶sub delta_md {
Subroutine delta_md: called CC=1 SCAR=0.0
Pod documented
1673 4 my $self = shift;
1674 4 my $dt = shift;
1675  
1676 4 my ( $smaller, $bigger ) = sort $self, $dt;
1677  
1678 4 my ( $months, $days, undef, undef, undef )
1679 = $dt->_adjust_for_positive_difference(
1680 $bigger->year * 12 + $bigger->month,
1681 $smaller->year * 12 + $smaller->month,
1682  
1683 $bigger->day, $smaller->day,
1684  
1685 0, 0,
1686  
1687 0, 0,
1688  
1689 0, 0,
1690  
1691 60,
1692  
1693 $smaller->_month_length( $smaller->year, $smaller->month ),
1694 );
1695  
1696 4 return $self->duration_class->new(
1697 months => $months,
1698 days => $days
1699 );
1700 }
1701  
1702 6 ▶sub delta_days {
Subroutine delta_days: called CC=1 SCAR=0.0
Pod documented
1703 6 my $self = shift;
1704 6 my $dt = shift;
1705  
1706 6 my $days
1707 = abs( ( $self->local_rd_values )[0] - ( $dt->local_rd_values )[0] );
1708  
1709 6 $self->duration_class->new( days => $days );
1710 }
1711  
1712 3 ▶sub delta_ms {
Subroutine delta_ms: called CC=1 SCAR=0.0
Pod documented
1713 3 my $self = shift;
1714 3 my $dt = shift;
1715  
1716 3 my ( $smaller, $greater ) = sort $self, $dt;
1717  
1718 3 my $days = int( $greater->jd - $smaller->jd );
1719  
1720 3 my $dur = $greater->subtract_datetime($smaller);
1721  
1722 3 my %p;
1723 3 $p{hours} = $dur->hours + ( $days * 24 );
1724 3 $p{minutes} = $dur->minutes;
1725 3 $p{seconds} = $dur->seconds;
1726  
1727 3 return $self->duration_class->new(%p);
1728 }
1729  
1730 9139 ▶sub _add_overload {
Subroutine _add_overload: called CC=3 SCAR=11.1
1731 9139 my ( $dt, $dur, $reversed ) = @_;
1732  
1733 9139 ▶ if ($reversed) {
Branch: 1 branch
BranchTrueFalseTotal
if ($reversed) 0 9139 9139
1734 0 ( $dur, $dt ) = ( $dt, $dur );
1735 }
1736  
1737 9139 ▶ unless ( DateTime::Helpers::isa( $dur, 'DateTime::Duration' ) ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (DateTime::Helpers::isa($dur, "DateTime::Duration")) 2 9137 9139
1738 2 my $class = ref $dt;
1739 2 my $dt_string = overload::StrVal($dt);
1740  
1741 2 Carp::croak( "Cannot add $dur to a $class object ($dt_string).\n"
1742 . ' Only a DateTime::Duration object can '
1743 . " be added to a $class object." );
1744 }
1745  
1746 9137 return $dt->clone->add_duration($dur);
1747 }
1748  
1749 22810 ▶sub _subtract_overload {
Subroutine _subtract_overload: called CC=4 SCAR=13.9
1750 22810 my ( $date1, $date2, $reversed ) = @_;
1751  
1752 22810 ▶ if ($reversed) {
Branch: 1 branch
BranchTrueFalseTotal
if ($reversed) 0 22810 22810
1753 0 ( $date2, $date1 ) = ( $date1, $date2 );
1754 }
1755  
1756 22810 ▶ if ( DateTime::Helpers::isa( $date2, 'DateTime::Duration' ) ) {
Branch: 2 branches
BranchTrueFalseTotal
if (DateTime::Helpers::isa($date2, 'DateTime::Duration')) { } 22788 22 22810
elsif (DateTime::Helpers::isa($date2, 'DateTime')) { } 20 2 22
1757 22788 my $new = $date1->clone;
1758 22788 $new->add_duration( $date2->inverse );
1759 22788 return $new;
1760 }
1761 elsif ( DateTime::Helpers::isa( $date2, 'DateTime' ) ) {
1762 20 return $date1->subtract_datetime($date2);
1763 }
1764 else {
1765 2 my $class = ref $date1;
1766 2 my $dt_string = overload::StrVal($date1);
1767  
1768 2 Carp::croak(
1769 "Cannot subtract $date2 from a $class object ($dt_string).\n"
1770 . ' Only a DateTime::Duration or DateTime object can '
1771 . " be subtracted from a $class object." );
1772 }
1773 }
1774  
1775 648 ▶sub add {
Subroutine add: called CC=1 SCAR=0.0
Pod documented
1776 648 my $self = shift;
1777  
1778 648 return $self->add_duration( $self->_duration_object_from_args(@_) );
1779 }
1780  
1781 54 ▶sub subtract {
Subroutine subtract: called CC=3 SCAR=11.0
Pod documented
1782 54 my $self = shift;
1783  
1784 54 my %eom;
1785 54 ▶ if ( @_ % 2 == 0 ) {
Branch: 1 branch
BranchTrueFalseTotal
if (@_ % 2 == 0) 53 1 54
1786 53 my %p = @_;
1787  
1788 $eom{end_of_month} = delete $p{end_of_month}
1789 53 ▶ if exists $p{end_of_month};
Branch: 1 branch
BranchTrueFalseTotal
if exists $p{"end_of_month"} 1 52 53
1790 }
1791  
1792 54 my $dur = $self->_duration_object_from_args(@_)->inverse(%eom);
1793  
1794 54 return $self->add_duration($dur);
1795 }
1796  
1797 # Syntactic sugar for add and subtract: use a duration object if it's
1798 # supplied, otherwise build a new one from the arguments.
1799  
1800 702 ▶sub _duration_object_from_args {
Subroutine _duration_object_from_args: called CC=4 SCAR=14.1
1801 702 my $self = shift;
1802  
1803 702 ▶ return $_[0]
Branch: 1 branch
BranchTrueFalseTotal
if @_ == 1 and builtin::blessed($_[0]) and $_[0]->isa($self->duration_class) 2 700 702
Condition66%4/6
@_ == 1 and builtin::blessed($_[0]) and $_[0]->isa($self->duration_class)
!ll&&!rl&&r
70002
@_ == 1 and builtin::blessed($_[0])
!ll&&!rl&&r
70002
MC/DC33%1/3
@_ == 1 and builtin::blessed($_[0]) and $_[0]->isa($self->duration_class)
@_ == 1 builtin::blessed($_[0]) $_[0]->isa($self->duration_class)
Truth table50%2/4
A and B and C
A= @_ == 1B= builtin::blessed($_[0])C= $_[0]->isa($self->duration_class)
ABCresult
0XX0
10X0
1100
1111
1804 if @_ == 1 && blessed( $_[0] ) && $_[0]->isa( $self->duration_class );
1805  
1806 700 return $self->duration_class->new(@_);
1807 }
1808  
1809 17 ▶sub subtract_duration { return $_[0]->add_duration( $_[1]->inverse ) }
Subroutine subtract_duration: called CC=1 SCAR=0.0
Pod documented
1810  
1811 {
1812 49 my $validator = validation_for(
1813 name => '_check_add_duration_params',
1814 name_is_optional => 1,
1815 params => [
1816 { type => t('Duration') },
1817 ],
1818 );
1819  
1820 ## no critic (Subroutines::ProhibitExcessComplexity)
1821 32672 ▶ sub add_duration {
Subroutine add_duration: called CC=7 SCAR=19.5
Pod documented
1822 32672 my $self = shift;
1823 32672 my ($dur) = $validator->(@_);
1824  
1825 # simple optimization
1826 32672 ▶ return $self if $dur->is_zero;
Branch: 1 branch
BranchTrueFalseTotal
if $dur->is_zero 744 31928 32672
1827  
1828 31928 my %deltas = $dur->deltas;
1829  
1830 # This bit isn't quite right since DateTime::Infinite::Future -
1831 # infinite duration should NaN
1832 31928 for my $val ( values %deltas ) {
1833 159632 my $inf;
1834 159632 ▶ if ( $val == INFINITY ) {
Branch: 2 branches
BranchTrueFalseTotal
if ($val == 9**9**9) { } 1 159631 159632
elsif ($val == -9**9**9) { } 1 159630 159631
1835 1 $inf = DateTime::Infinite::Future->new;
1836 }
1837 elsif ( $val == NEG_INFINITY ) {
1838 1 $inf = DateTime::Infinite::Past->new;
1839 }
1840  
1841 159632 ▶ if ($inf) {
Branch: 1 branch
BranchTrueFalseTotal
if ($inf) 2 159630 159632
1842 2 %$self = %$inf;
1843 2 bless $self, ref $inf;
1844  
1845 2 return $self;
1846 }
1847 }
1848  
1849 31926 ▶ return $self if $self->is_infinite;
Branch: 1 branch
BranchTrueFalseTotal
if $self->is_infinite 4 31922 31926
1850  
1851 31922 my %orig = %{$self};
1852 31922 ▶ try {
Subroutine __ANON__: called CC=1 SCAR=0.0
1853 31922 $self->_add_duration($dur);
1854 }
1855 2 ▶ catch {
Subroutine __ANON__: called CC=1 SCAR=0.0
1856 2 %{$self} = %orig;
1857 2 die $_;
1858 31922 };
1859 }
1860 }
1861  
1862 49 ▶sub _add_duration {
Subroutine _add_duration: called CC=15 SCAR=27.1
1863 31922 my $self = shift;
1864 31922 my $dur = shift;
1865  
1866 31922 my %deltas = $dur->deltas;
1867  
1868 31922 ▶ if ( $deltas{days} ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($deltas{"days"}) 23757 8165 31922
1869 23757 $self->{local_rd_days} += $deltas{days};
1870  
1871 23757 $self->{utc_year} += int( $deltas{days} / 365 ) + 1;
1872 }
1873  
1874 31922 ▶ if ( $deltas{months} ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($deltas{"months"}) 540 31382 31922
1875  
1876 # For preserve mode, if it is the last day of the month, make
1877 # it the 0th day of the following month (which then will
1878 # normalize back to the last day of the new month).
1879 my ( $y, $m, $d ) = (
1880 $dur->is_preserve_mode
1881 ? $self->_rd2ymd( $self->{local_rd_days} + 1 )
1882 : $self->_rd2ymd( $self->{local_rd_days} )
1883 540 ▶ );
Branch: 1 branch
BranchTrueFalseTotal
$dur->is_preserve_mode ? : 113 427 540
1884  
1885 540 ▶ $d -= 1 if $dur->is_preserve_mode;
Branch: 1 branch
BranchTrueFalseTotal
if $dur->is_preserve_mode 113 427 540
1886  
1887 540 ▶ if ( !$dur->is_wrap_mode && $d > 28 ) {
Branch: 1 branch
BranchTrueFalseTotal
if (not $dur->is_wrap_mode and $d > 28) { } 2 538 540
Condition100%3/3
not $dur->is_wrap_mode and $d > 28
!ll&&!rl&&r
4251132
MC/DC100%2/2
not $dur->is_wrap_mode and $d > 28
not $dur->is_wrap_mode $d > 28
Truth table100%3/3
not(A) and B
A= not $dur->is_wrap_modeB= $d > 28
ABresult
0X0
100
111
1888  
1889 # find the rd for the last day of our target month
1890 $self->{local_rd_days}
1891 2 = $self->_ymd2rd( $y, $m + $deltas{months} + 1, 0 );
1892  
1893 # what day of the month is it? (discard year and month)
1894 my $last_day
1895 2 = ( $self->_rd2ymd( $self->{local_rd_days} ) )[2];
1896  
1897 # if our original day was less than the last day,
1898 # use that instead
1899 2 ▶ $self->{local_rd_days} -= $last_day - $d if $last_day > $d;
Branch: 1 branch
BranchTrueFalseTotal
if $last_day > $d 1 1 2
1900 }
1901 else {
1902 $self->{local_rd_days}
1903 538 = $self->_ymd2rd( $y, $m + $deltas{months}, $d );
1904 }
1905  
1906 540 $self->{utc_year} += int( $deltas{months} / 12 ) + 1;
1907 }
1908  
1909 31922 ▶ if ( $deltas{days} || $deltas{months} ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($deltas{"days"} or $deltas{"months"}) 24294 7628 31922
Condition100%3/3
$deltas{"days"} or $deltas{"months"}
l!l&&r!l&&!r
237575377628
MC/DC100%2/2
$deltas{"days"} or $deltas{"months"}
$deltas{"days"} $deltas{"months"}
Truth table100%3/3
A or B
A= $deltas{"days"}B= $deltas{"months"}
ABresult
1X1
011
000
1910 24294 $self->_calc_utc_rd;
1911  
1912 24292 $self->_handle_offset_modifier( $self->second );
1913 }
1914  
1915 31920 ▶ if ( $deltas{minutes} ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($deltas{"minutes"}) 74 31846 31920
1916 74 $self->{utc_rd_secs} += $deltas{minutes} * 60;
1917  
1918 # This intentionally ignores leap seconds
1919 $self->_normalize_tai_seconds(
1920 $self->{utc_rd_days},
1921 $self->{utc_rd_secs}
1922 74 );
1923 }
1924  
1925 31920 ▶ if ( $deltas{seconds} || $deltas{nanoseconds} ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($deltas{"seconds"} or $deltas{"nanoseconds"}) 7577 24343 31920
Condition100%3/3
$deltas{"seconds"} or $deltas{"nanoseconds"}
l!l&&r!l&&!r
7574324343
MC/DC100%2/2
$deltas{"seconds"} or $deltas{"nanoseconds"}
$deltas{"seconds"} $deltas{"nanoseconds"}
Truth table100%3/3
A or B
A= $deltas{"seconds"}B= $deltas{"nanoseconds"}
ABresult
1X1
011
000
1926 7577 $self->{utc_rd_secs} += $deltas{seconds};
1927  
1928 7577 ▶ if ( $deltas{nanoseconds} ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($deltas{"nanoseconds"}) 3 7574 7577
1929 3 $self->{rd_nanosecs} += $deltas{nanoseconds};
1930 $self->_normalize_nanoseconds(
1931 $self->{utc_rd_secs},
1932 $self->{rd_nanosecs}
1933 3 );
1934 }
1935  
1936 7577 $self->_normalize_seconds;
1937  
1938 # This might be some big number much bigger than 60, but
1939 # that's ok (there are tests in 19leap_second.t to confirm
1940 # that)
1941 7577 $self->_handle_offset_modifier( $self->second + $deltas{seconds} );
1942 }
1943  
1944 my $new = ( ref $self )->from_object(
1945 object => $self,
1946 locale => $self->{locale},
1947 31920 ▶ ( $self->{formatter} ? ( formatter => $self->{formatter} ) : () ),
Branch: 1 branch
BranchTrueFalseTotal
$self->{'formatter'} ? : 0 31920 31920
1948 );
1949  
1950 31920 %$self = %$new;
1951  
1952 31920 return $self;
1953 }
1954  
1955 8932 ▶sub _compare_overload {
Subroutine _compare_overload: called CC=3 SCAR=11.0
1956  
1957 # note: $_[1]->compare( $_[0] ) is an error when $_[1] is not a
1958 # DateTime (such as the INFINITY value)
1959  
1960 8932 ▶ return undef unless defined $_[1];
Branch: 1 branch
BranchTrueFalseTotal
unless defined $_[1] 2 8930 8932
1961  
1962 8930 ▶ return $_[2] ? -$_[0]->compare( $_[1] ) : $_[0]->compare( $_[1] );
Branch: 1 branch
BranchTrueFalseTotal
$_[2] ? : 1 8929 8930
1963 }
1964  
1965 22 ▶sub _string_compare_overload {
Subroutine _string_compare_overload: called CC=3 SCAR=11.0
1966 22 my ( $dt1, $dt2, $flip ) = @_;
1967  
1968 # One is a DateTime object, one isn't. Just stringify and compare.
1969 22 ▶ if ( !DateTime::Helpers::can( $dt2, 'utc_rd_values' ) ) {
Branch: 1 branch
BranchTrueFalseTotal
if (not DateTime::Helpers::can($dt2, 'utc_rd_values')) { } 12 10 22
1970 12 ▶ my $sign = $flip ? -1 : 1;
Branch: 1 branch
BranchTrueFalseTotal
$flip ? : 2 10 12
1971 12 return $sign * ( "$dt1" cmp "$dt2" );
1972 }
1973 else {
1974 10 my $meth = $dt1->can('_compare_overload');
1975 10 goto $meth;
1976 }
1977 }
1978  
1979 9007 ▶sub compare {
Subroutine compare: called CC=1 SCAR=0.0
Pod documented
1980 9007 shift->_compare( @_, 0 );
1981 }
1982  
1983 2 ▶sub compare_ignore_floating {
Subroutine compare_ignore_floating: called CC=1 SCAR=0.0
Pod documented
1984 2 shift->_compare( @_, 1 );
1985 }
1986  
1987 9009 ▶sub _compare {
Subroutine _compare: called CC=17 SCAR=28.4
1988 9009 ▶ my ( undef, $dt1, $dt2, $consistent ) = ref $_[0] ? ( undef, @_ ) : @_;
Branch: 1 branch
BranchTrueFalseTotal
ref $_[0] ? : 8952 57 9009
1989  
1990 9009 ▶ return undef unless defined $dt2;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $dt2 0 9009 9009
1991  
1992 9009 ▶ if ( !ref $dt2 && ( $dt2 == INFINITY || $dt2 == NEG_INFINITY ) ) {
Branch: 1 branch
BranchTrueFalseTotal
if (not ref $dt2 and $dt2 == "Inf" || $dt2 == "-Inf") 6 9003 9009
Condition100%6/6
not ref $dt2 and $dt2 == "Inf" || $dt2 == "-Inf"
!ll&&!rl&&r
900216
$dt2 == "Inf" or $dt2 == "-Inf"
l!l&&r!l&&!r
421
MC/DC100%3/3
not ref $dt2 and $dt2 == "Inf" || $dt2 == "-Inf"
not ref $dt2 $dt2 == "Inf" $dt2 == "-Inf"
Truth table100%4/4
not(A) and B or C
A= not ref $dt2B= $dt2 == "Inf"C= $dt2 == "-Inf"
ABCresult
0XX0
1000
11X1
1011
1993 6 return $dt1->{utc_rd_days} <=> $dt2;
1994 }
1995  
1996 9003 ▶ unless ( DateTime::Helpers::can( $dt1, 'utc_rd_values' )
Branch: 1 branch
BranchTrueFalseTotal
unless (DateTime::Helpers::can($dt1, "utc_rd_values") and DateTime::Helpers::can($dt2, "utc_rd_values")) 2 9001 9003
Condition66%2/3
DateTime::Helpers::can($dt1, "utc_rd_values") and DateTime::Helpers::can($dt2, "utc_rd_values")
!ll&&!rl&&r
029001
MC/DC50%1/2
DateTime::Helpers::can($dt1, "utc_rd_values") and DateTime::Helpers::can($dt2, "utc_rd_values")
DateTime::Helpers::can($dt1, "utc_rd_values") DateTime::Helpers::can($dt2, "utc_rd_values")
Truth table66%2/3
A and B
A= DateTime::Helpers::can($dt1, "utc_rd_values")B= DateTime::Helpers::can($dt2, "utc_rd_values")
ABresult
0X0
100
111
1997 && DateTime::Helpers::can( $dt2, 'utc_rd_values' ) ) {
1998 2 my $dt1_string = overload::StrVal($dt1);
1999 2 my $dt2_string = overload::StrVal($dt2);
2000  
2001 2 Carp::croak( 'A DateTime object can only be compared to'
2002 . " another DateTime object ($dt1_string, $dt2_string)." );
2003 }
2004  
2005 9001 ▶ if ( !$consistent
Branch: 1 branch
BranchTrueFalseTotal
if (not $consistent and DateTime::Helpers::can($dt1, "time_zone") and DateTime::Helpers::can($dt2, "time_zone")) 8997 4 9001
Condition83%5/6
not $consistent and DateTime::Helpers::can($dt1, "time_zone") and DateTime::Helpers::can($dt2, "time_zone")
!ll&&!rl&&r
228997
not $consistent and DateTime::Helpers::can($dt1, "time_zone")
!ll&&!rl&&r
208999
MC/DC66%2/3
not $consistent and DateTime::Helpers::can($dt1, "time_zone") and DateTime::Helpers::can($dt2, "time_zone")
not $consistent DateTime::Helpers::can($dt1, "time_zone") DateTime::Helpers::can($dt2, "time_zone")
Truth table75%3/4
not(A) and B and C
A= not $consistentB= DateTime::Helpers::can($dt1, "time_zone")C= DateTime::Helpers::can($dt2, "time_zone")
ABCresult
0XX0
10X0
1100
1111
2006 && DateTime::Helpers::can( $dt1, 'time_zone' )
2007 && DateTime::Helpers::can( $dt2, 'time_zone' ) ) {
2008 8997 my $is_floating1 = $dt1->time_zone->is_floating;
2009 8997 my $is_floating2 = $dt2->time_zone->is_floating;
2010  
2011 8997 ▶ if ( $is_floating1 && !$is_floating2 ) {
Branch: 2 branches
BranchTrueFalseTotal
if ($is_floating1 and not $is_floating2) { } 2 8995 8997
elsif ($is_floating2 and not $is_floating1) { } 3 9103 9106
Condition100%3/3
$is_floating1 and not $is_floating2
!ll&&!rl&&r
11488812
MC/DC100%2/2
$is_floating1 and not $is_floating2
$is_floating1 not $is_floating2
Truth table100%3/3
A and not(B)
A= $is_floating1B= not $is_floating2
ABresult
0X0
100
111
2012 2 $dt1 = $dt1->clone->set_time_zone( $dt2->time_zone );
2013 }
2014 ▶ elsif ( $is_floating2 && !$is_floating1 ) {
Condition100%3/3
$is_floating2 and not $is_floating1
!ll&&!rl&&r
11188813
MC/DC100%2/2
$is_floating2 and not $is_floating1
$is_floating2 not $is_floating1
Truth table100%3/3
A and not(B)
A= $is_floating2B= not $is_floating1
ABresult
0X0
100
111
2015 3 $dt2 = $dt2->clone->set_time_zone( $dt1->time_zone );
2016 }
2017 }
2018  
2019 9001 my @dt1_components = $dt1->utc_rd_values;
2020 9001 my @dt2_components = $dt2->utc_rd_values;
2021  
2022 9001 for my $i ( 0 .. 2 ) {
2023 9172 ▶ return $dt1_components[$i] <=> $dt2_components[$i]
Branch: 1 branch
BranchTrueFalseTotal
if $dt1_components[$i] != $dt2_components[$i] 8933 239 9172
2024 if $dt1_components[$i] != $dt2_components[$i];
2025 }
2026  
2027 68 return 0;
2028 }
2029  
2030 5 ▶sub is_between {
Subroutine is_between: called CC=2 SCAR=6.9
Pod documented
2031 5 my $self = shift;
2032 5 my $lower = shift;
2033 5 my $upper = shift;
2034  
2035 5 ▶ return $self->compare($lower) > 0 && $self->compare($upper) < 0;
Condition100%3/3
$self->compare($lower) > 0 && $self->compare($upper) < 0
!ll&&!rl&&r
311
MC/DC100%2/2
$self->compare($lower) > 0 && $self->compare($upper) < 0
$self->compare($lower) > 0 $self->compare($upper) < 0
Truth table100%3/3
A && B
A= $self->compare($lower) > 0B= $self->compare($upper) < 0
ABresult
0X0
100
111
2036 }
2037  
2038 16 ▶sub _string_equals_overload {
Subroutine _string_equals_overload: called CC=4 SCAR=14.5
2039 16 ▶ my ( $class, $dt1, $dt2 ) = ref $_[0] ? ( undef, @_ ) : @_;
Branch: 1 branch
BranchTrueFalseTotal
ref $_[0] ? : 16 0 16
2040  
2041 16 ▶ if ( !DateTime::Helpers::can( $dt2, 'utc_rd_values' ) ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (DateTime::Helpers::can($dt2, "utc_rd_values")) 10 6 16
2042 10 return "$dt1" eq "$dt2";
2043 }
2044  
2045 6 ▶ $class ||= ref $dt1;
Condition33%1/3
$class ||= ref $dt1
l!l&&r!l&&!r
060
MC/DC0%0/2
$class ||= ref $dt1
$class ref $dt1
Truth table33%1/3
A ||= B
A= $classB= ref $dt1
ABresult
1X1
011
000
2046 6 return !$class->compare( $dt1, $dt2 );
2047 }
2048  
2049 6 ▶sub _string_not_equals_overload {
Subroutine _string_not_equals_overload: called CC=1 SCAR=0.0
2050 6 return !_string_equals_overload(@_);
2051 }
2052  
2053 57549 ▶sub _normalize_nanoseconds {
Subroutine _normalize_nanoseconds: called CC=3 SCAR=11.0
2054 49 ▶ use integer;
Subroutine BEGIN: called CC=1 SCAR=0.0
2055  
2056 # seconds, nanoseconds
2057 57549 ▶ if ( $_[2] < 0 ) {
Branch: 2 branches
BranchTrueFalseTotal
if ($_[2] < 0) { } 1 57548 57549
elsif ($_[2] >= 1000000000) { } 1 57547 57548
2058 1 my $overflow = 1 + $_[2] / MAX_NANOSECONDS;
2059 1 $_[2] += $overflow * MAX_NANOSECONDS;
2060 1 $_[1] -= $overflow;
2061 }
2062 elsif ( $_[2] >= MAX_NANOSECONDS ) {
2063 1 my $overflow = $_[2] / MAX_NANOSECONDS;
2064 1 $_[2] -= $overflow * MAX_NANOSECONDS;
2065 1 $_[1] += $overflow;
2066 }
2067 }
2068  
2069 {
2070 49 my $validator = validation_for(
2071 name => '_check_set_params',
2072 name_is_optional => 1,
2073 params => {
2074 year => {
2075 type => t('Year'),
2076 optional => 1,
2077 },
2078 month => {
2079 type => t('Month'),
2080 optional => 1,
2081 },
2082 day => {
2083 type => t('DayOfMonth'),
2084 optional => 1,
2085 },
2086 hour => {
2087 type => t('Hour'),
2088 optional => 1,
2089 },
2090 minute => {
2091 type => t('Minute'),
2092 optional => 1,
2093 },
2094 second => {
2095 type => t('Second'),
2096 optional => 1,
2097 },
2098 nanosecond => {
2099 type => t('Nanosecond'),
2100 optional => 1,
2101 },
2102 locale => {
2103 type => t('Locale'),
2104 optional => 1,
2105 },
2106 },
2107 );
2108  
2109 ## no critic (NamingConventions::ProhibitAmbiguousNames)
2110 42 ▶ sub set {
Subroutine set: called CC=2 SCAR=7.1
Pod documented
2111 42 my $self = shift;
2112 42 my %p = $validator->(@_);
2113  
2114 32 ▶ if ( $p{locale} ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($p{"locale"}) 0 32 32
2115 0 carp 'You passed a locale to the set() method.'
2116 . ' You should use set_locale() instead, as using set() may alter the local time near a DST boundary.';
2117 }
2118  
2119 32 my $new_dt = $self->_new_from_self(%p);
2120  
2121 32 %$self = %$new_dt;
2122  
2123 32 return $self;
2124 }
2125 }
2126  
2127 1 ▶sub set_year { $_[0]->set( year => $_[1] ) }
Subroutine set_year: called CC=1 SCAR=0.0
Pod documented
2128 1 ▶sub set_month { $_[0]->set( month => $_[1] ) }
Subroutine set_month: called CC=1 SCAR=0.0
Pod documented
2129 1 ▶sub set_day { $_[0]->set( day => $_[1] ) }
Subroutine set_day: called CC=1 SCAR=0.0
Pod documented
2130 1 ▶sub set_hour { $_[0]->set( hour => $_[1] ) }
Subroutine set_hour: called CC=1 SCAR=0.0
Pod documented
2131 1 ▶sub set_minute { $_[0]->set( minute => $_[1] ) }
Subroutine set_minute: called CC=1 SCAR=0.0
Pod documented
2132 1 ▶sub set_second { $_[0]->set( second => $_[1] ) }
Subroutine set_second: called CC=1 SCAR=0.0
Pod documented
2133 1 ▶sub set_nanosecond { $_[0]->set( nanosecond => $_[1] ) }
Subroutine set_nanosecond: called CC=1 SCAR=0.0
Pod documented
2134  
2135 # These two are special cased because ... if the local time is the hour of a
2136 # DST change where the same local time occurs twice then passing it through
2137 # _new() can actually change the underlying UTC time, which is bad.
2138  
2139 {
2140 49 my $validator = validation_for(
2141 name => '_check_set_locale_params',
2142 name_is_optional => 1,
2143 params => [
2144 { type => t( 'Maybe', of => t('Locale') ) },
2145 ],
2146 );
2147  
2148 3 ▶ sub set_locale {
Subroutine set_locale: called CC=1 SCAR=0.0
Pod documented
2149 3 my $self = shift;
2150 3 my ($locale) = $validator->(@_);
2151  
2152 3 $self->_set_locale($locale);
2153  
2154 3 return $self;
2155 }
2156 }
2157  
2158 {
2159 49 my $validator = validation_for(
2160 name => '_check_set_formatter_params',
2161 name_is_optional => 1,
2162 params => [
2163 { type => t( 'Maybe', of => t('Formatter') ) },
2164 ],
2165 );
2166  
2167 2 ▶ sub set_formatter {
Subroutine set_formatter: called CC=1 SCAR=0.0
Pod documented
2168 2 my $self = shift;
2169 2 my ($formatter) = $validator->(@_);
2170  
2171 1 $self->{formatter} = $formatter;
2172  
2173 1 return $self;
2174 }
2175 }
2176  
2177 {
2178 49 my %TruncateDefault = (
2179 month => 1,
2180 day => 1,
2181 hour => 0,
2182 minute => 0,
2183 second => 0,
2184 nanosecond => 0,
2185 );
2186  
2187 49 my $validator = validation_for(
2188 name => '_check_truncate_params',
2189 name_is_optional => 1,
2190 params => {
2191 to => { type => t('TruncationLevel') },
2192 },
2193 );
2194  
2195 my $re = join '|', 'year', 'week', 'local_week', 'quarter',
2196 49 grep { $_ ne 'nanosecond' } keys %TruncateDefault;
2197 49 my $spec = { to => { regex => qr/^(?:$re)$/ } };
2198  
2199 ## no critic (Subroutines::ProhibitBuiltinHomonyms)
2200 174 ▶ sub truncate {
Subroutine truncate: called CC=9 SCAR=22.0
Pod documented
2201 174 my $self = shift;
2202 174 my %p = $validator->(@_);
2203  
2204 170 my %new;
2205 170 ▶ if ( $p{to} eq 'week' || $p{to} eq 'local_week' ) {
Branch: 2 branches
BranchTrueFalseTotal
if ($p{'to'} eq 'week' or $p{'to'} eq 'local_week') { } 25 145 170
elsif ($p{'to'} eq 'quarter') { } 108 37 145
Condition100%3/3
$p{"to"} eq "week" or $p{"to"} eq "local_week"
l!l&&r!l&&!r
916145
MC/DC100%2/2
$p{"to"} eq "week" or $p{"to"} eq "local_week"
$p{"to"} eq "week" $p{"to"} eq "local_week"
Truth table100%3/3
A or B
A= $p{"to"} eq "week"B= $p{"to"} eq "local_week"
ABresult
1X1
011
000
2206 my $first_day_of_week
2207 = ( $p{to} eq 'local_week' )
2208 ? $self->{locale}->first_day_of_week
2209 25 ▶ : 1;
Branch: 1 branch
BranchTrueFalseTotal
$p{'to'} eq 'local_week' ? : 16 9 25
2210  
2211 25 my $day_diff = ( $self->day_of_week - $first_day_of_week ) % 7;
2212  
2213 25 ▶ if ($day_diff) {
Branch: 1 branch
BranchTrueFalseTotal
if ($day_diff) 22 3 25
2214 22 $self->add( days => -1 * $day_diff );
2215 }
2216  
2217 # This can fail if the truncate ends up giving us an invalid local
2218 # date time. If that happens we need to reverse the addition we
2219 # just did. See https://rt.cpan.org/Ticket/Display.html?id=93347.
2220 25 ▶ try {
Subroutine __ANON__: called CC=1 SCAR=0.0
2221 25 $self->truncate( to => 'day' );
2222 }
2223 1 ▶ catch {
Subroutine __ANON__: called CC=1 SCAR=0.0
2224 1 $self->add( days => $day_diff );
2225 1 die $_;
2226 25 };
2227 }
2228 elsif ( $p{to} eq 'quarter' ) {
2229 108 %new = (
2230 year => $self->year,
2231 month => int( ( $self->month - 1 ) / 3 ) * 3 + 1,
2232 day => 1,
2233 hour => 0,
2234 minute => 0,
2235 second => 0,
2236 nanosecond => 0,
2237 );
2238 }
2239 else {
2240 37 my $truncate;
2241 37 for my $f (qw( year month day hour minute second nanosecond )) {
2242 259 ▶ $new{$f} = $truncate ? $TruncateDefault{$f} : $self->$f();
Branch: 1 branch
BranchTrueFalseTotal
$truncate ? : 143 116 259
2243  
2244 259 ▶ $truncate = 1 if $p{to} eq $f;
Branch: 1 branch
BranchTrueFalseTotal
if $p{"to"} eq $f 37 222 259
2245 }
2246 }
2247  
2248 169 my $new_dt = $self->_new_from_self( %new, _skip_validation => 1 );
2249  
2250 168 %$self = %$new_dt;
2251  
2252 168 return $self;
2253 }
2254 }
2255  
2256 49 ▶sub set_time_zone {
Subroutine set_time_zone: called CC=6 SCAR=17.9
Pod documented
2257 31991 my ( $self, $tz ) = @_;
2258  
2259 31991 ▶ if ( ref $tz ) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $tz) { } 31939 52 31991
2260  
2261 # This is a bit of a hack but it works because time zone objects
2262 # are singletons, and if it doesn't work all we lose is a little
2263 # bit of speed.
2264 31939 ▶ return $self if $self->{tz} eq $tz;
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"tz"} eq $tz 587 31352 31939
2265 }
2266 else {
2267 52 ▶ return $self if $self->{tz}->name eq $tz;
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"tz"}->name eq $tz 1 51 52
2268 }
2269  
2270 31403 my $was_floating = $self->{tz}->is_floating;
2271  
2272 31403 my $old_tz = $self->{tz};
2273 31403 ▶ $self->{tz} = ref $tz ? $tz : DateTime::TimeZone->new( name => $tz );
Branch: 1 branch
BranchTrueFalseTotal
ref $tz ? : 31352 51 31403
2274  
2275 31403 $self->_handle_offset_modifier( $self->second, 1 );
2276  
2277 31403 my $e;
2278 31403 ▶ try {
Subroutine __ANON__: called CC=4 SCAR=14.1
2279 # if it either was or now is floating (but not both)
2280 31403 ▶ if ( $self->{tz}->is_floating xor $was_floating ) {
Branch: 2 branches
BranchTrueFalseTotal
if ($self->{'tz'}->is_floating xor $was_floating) { } 31247 156 31403
elsif (not $was_floating) { } 156 0 156
Condition75%3/4
$self->{"tz"}->is_floating xor $was_floating
l&&rl&&!r!l&&r!l&&!r
0312425156
MC/DC100%2/2
$self->{"tz"}->is_floating xor $was_floating
$self->{"tz"}->is_floating $was_floating
Truth table75%3/4
A xor B
A= $self->{"tz"}->is_floatingB= $was_floating
ABresult
110
101
011
000
2281 31247 $self->_calc_utc_rd;
2282 }
2283 elsif ( !$was_floating ) {
2284 156 $self->_calc_local_rd;
2285 }
2286 }
2287 1 ▶ catch {
Subroutine __ANON__: called CC=1 SCAR=0.0
2288 1 $e = $_;
2289 31403 };
2290  
2291 # If we can't recalc the RD values then we shouldn't keep the new TZ. RT
2292 # #83940
2293 31403 ▶ if ($e) {
Branch: 1 branch
BranchTrueFalseTotal
if ($e) 1 31402 31403
2294 1 $self->{tz} = $old_tz;
2295 1 die $e;
2296 }
2297  
2298 31402 return $self;
2299 }
2300  
2301 4 ▶sub STORABLE_freeze {
Subroutine STORABLE_freeze: called CC=3 SCAR=11.0
Pod undocumented
2302 4 my $self = shift;
2303  
2304 4 my $serialized = q{};
2305 4 for my $key (
2306 qw( utc_rd_days
2307 utc_rd_secs
2308 rd_nanosecs )
2309 ) {
2310 12 $serialized .= "$key:$self->{$key}|";
2311 }
2312  
2313 # not used yet, but may be handy in the future.
2314 4 ▶ $serialized .= 'version:' . ( $DateTime::VERSION || 'git' );
Condition50%1/2
$DateTime::VERSION || 'git'
l!l
40
MC/DC0%0/1
$DateTime::VERSION || 'git'
$DateTime::VERSION
Truth table50%1/2
A
A= $DateTime::VERSION
Aresult
11
00
2315  
2316 # Formatter needs to be returned as a reference since it may be
2317 # undef or a class name, and Storable will complain if extra
2318 # return values aren't refs
2319 4 return $serialized, $self->{locale}, $self->{tz}, \$self->{formatter};
2320 }
2321  
2322 4 ▶sub STORABLE_thaw {
Subroutine STORABLE_thaw: called CC=3 SCAR=11.1
Pod undocumented
2323 4 my $self = shift;
2324 4 shift;
2325 4 my $serialized = shift;
2326  
2327 4 my %serialized = map { split /:/ } split /\|/, $serialized;
2328  
2329 4 my ( $locale, $tz, $formatter );
2330  
2331 # more recent code version
2332 4 ▶ if (@_) {
Branch: 1 branch
BranchTrueFalseTotal
if (@_) { } 4 0 4
2333 4 ( $locale, $tz, $formatter ) = @_;
2334 }
2335 else {
2336 0 $tz = DateTime::TimeZone->new( name => delete $serialized{tz} );
2337  
2338 0 $locale = DateTime::Locale->load( delete $serialized{locale} );
2339 }
2340  
2341 4 delete $serialized{version};
2342  
2343 my $object = bless {
2344 utc_vals => [
2345 $serialized{utc_rd_days},
2346 $serialized{utc_rd_secs},
2347 $serialized{rd_nanosecs},
2348 4 ],
2349 tz => $tz,
2350 },
2351 'DateTime::_Thawed';
2352  
2353 4 ▶ my %formatter = defined $$formatter ? ( formatter => $$formatter ) : ();
Branch: 1 branch
BranchTrueFalseTotal
defined $$formatter ? : 1 3 4
2354 4 my $new = ( ref $self )->from_object(
2355 object => $object,
2356 locale => $locale,
2357 %formatter,
2358 );
2359  
2360 4 %$self = %$new;
2361  
2362 4 return $self;
2363 }
2364  
2365 ## no critic (Modules::ProhibitMultiplePackages)
2366 package # hide from PAUSE
2367 DateTime::_Thawed;
2368  
2369 4 ▶sub utc_rd_values { @{ $_[0]->{utc_vals} } }
Subroutine utc_rd_values: called CC=1 SCAR=0.0
2370  
2371 8 ▶sub time_zone { $_[0]->{tz} }
Subroutine time_zone: called CC=1 SCAR=0.0
2372  
2373 49 1;
2374  
2375 # ABSTRACT: A date and time object for Perl
2376  
2377 __END__
« blib/lib/DateTime/PPExtra.pm ↑ Summary blib/lib/DateTime/Duration.pm »