Class-Date-1.1.15/000755 000765 000024 00000000000 12331601600 013744 5ustar00gaborstaff000000 000000 Class-Date-1.1.15/Changes000644 000765 000024 00000012573 12331601433 015253 0ustar00gaborstaff000000 000000 Revision history for Perl extension Class::Date. 1.1.15 Mon May 5 06:18:37 2014 - Don't require Env::C due to RT #95332 1.1.14 Sat May 3 11:02:33 2014 - Move Date/Const.pm to lib/Calss/Date/ - Move Class::Date::Invalid and Class::Date::Rel to their own files in lib/Class/Date/ - Require Scalar::Util and remove work-around lack of Scalar::Util - Require Env::C 1.1.13 Fri May 2 08:32:15 2014 - Use Test::More for testing 1.1.12 Wed Apr 30 08:44:29 2014 - Fixing MANIFEST.SKIP to include Makefile.PL and exclue MYMETA files. 1.1.11 Wed Apr 30 06:56:24 2014 - Convert the pod to UTF8 and add =encoding RT #94657 - Minumum version of perl is not 5.006 - Makefile updated - New maintainer: Gabor Szabo 1.1.10 Sun Jul 18 13:27:39 CEST 2010 - Remove the deprecated UNIVERSAL::import (Vladimir Timofeev) 1.1.9 Sun May 14 22:52:50 CEST 2006 - Added "meridiam" and "ampm" methods by llarian 1.1.8 Sun Nov 6 16:36:54 CET 2005 - Added Env::C support for mod_perl environments - Added documentation about thread-safety and mod_perl issues 1.1.7 Wed Aug 20 23:16:29 CEST 2003 - Bugfix in Date::Parse support 1.1.6 Sun Mar 16 18:05:23 CET 2003 - Introducing the NOTZ_TIMEZONE variable to support local time calculations, where TZ variables are not set. 1.1.5 Wed Feb 5 23:17:50 CET 2003 - Small documentation fix 1.1.4 Wed Feb 5 11:15:20 CET 2003 (test release) - Restored the usage of gmtime and timegm methods, because I cannot solve the timezone issues on win32 platform. 1.1.3 Fri Jan 3 09:07:01 CET 2003 - Fixed a warning in the strftime method 1.1.2 Sat Dec 14 14:46:41 CET 2002 - Test and report buggy strftime implementation - Fix for strftime - Hardcoded "Class::Date" class names are removed, to enhance inheritance 1.1.1 Wed Aug 28 23:30:43 CEST 2002 - errstr method of Class::Date::Invalid is documented - Timezone set fix for perl 5.8.0 - Fix for the missing "tzname" declaration on OSX. - NOTE: gmdate and timezone support still does not work on win32! 1.1.0 Mon Jul 15 20:24:04 CEST 2002 - Date::Parse support now works well with partly defined dates. - Full timezone support (except on the win32 platform) 1.0.10 Sun Mar 10 21:45:58 CET 2002 - Extend the range of operation to 1902-2038 where the underlying system (perl, POSIX functions) support 1.0.9 Mon Feb 25 23:19:49 CET 2002 - is_leap_year function added 1.0.8 Wed Nov 7 12:15:28 CET 2001 - fix Time::Local detection in perl 5.005_03 - The module is now working without a C compiler - You will get warnings if you request for Date::Parse, but it cannot be found 1.0.7 Mon Oct 15 00:22:47 CEST 2001 - fix for function name clash in bleadperl - Documentation update: Win32 and support chapters added, Development focus rewritten 1.0.6 Thu Oct 11 14:26:27 CEST 2001 - Fixed a bug with month_end and newer stable perls (5.6.1) - Fixed a bug with Time::Local in perl 5.7.2 1.0.5 Tue Jul 17 14:31:00 CEST 2001 - Restored and documented the compatibility issues with perl 5.005 1.0.4 Tue Jul 12 11:00:46 CEST 2001 - Fix a bug with RANGE_CHECK in addition 1.0.3 Tue Jul 3 13:09:04 CEST 2001 - "errmsg" method is not works as expected - "errstr" is now an alias to "errmsg" 1.0.2 Wed Jun 27 00:08:05 CEST 2001 - "set" method is renamed to "clone" - named interface is documented - minor documentation fixes 1.0.1 Sat Jun 16 16:14:02 CEST 2001 - added a "set" method to change parts of the date - fix the "href" method - Added a $RANGE_CHECK variable, to possiby disable dates like "2001-02-31" - Added error handling - Restored compatibility with perl 5.005 1.0.0 Mon Jun 11 14:58:29 CEST 2001 - it is now requires perl 5.6 because of using Time::Local - stable release, basically the same as 0.98 0.98 Tue May 22 16:46:03 CEST 2001 - bug in "truncate" method fixed - documentation changes 0.97 Wed May 16 23:10:17 CEST 2001 - Accepts the date in "YYYY-MM-DD HH:MM" format - uses Time::Local instead of strftime("%s"), because the latter is not available in not GNU environment 0.96 Fri May 11 01:42:36 CEST 2001 - Fixed $DST_ADJUST bug when adding months - Added $MONTH_BORDER_ADJUST variable and documentation for it - Added "month_begin", "month_end" and "days_in_month" method - Fixed the "aref" method - Doc. grammar fixes 0.95 Thu May 10 00:11:43 CEST 2001 - Fixed comparison problem with undef - date("2001-01-31")+'1M'-'1M' != "2001-01-31" "bug" documented - Fixed the module name in two places (it was Date::Class) 0.94 Thu Apr 26 16:30:39 CEST 2001 - $date-'1D' bug fixed - added "now" function 0.93 Wed Apr 18 12:55:15 CEST 2001 - the return value from Date::Parse is fixed 0.92 Tue Apr 17 17:23:10 CEST 2001 - made 'Date::Parse' usage optional 0.91 Mon Apr 9 13:42:49 CEST 2001 - small bugfixes for perl 5.005 - date(undef) and Class::Date::Rel(undef) returns undef - array method fix (year + 1900, month + 1) - $DATE_FORMAT is not exportable any more (confusing) - test fixes 0.90 Thu Apr 5 13:18:18 CEST 2001 - Complete rewrite based on Matt Sergeant's Time::Object - Can handle GMT and local time also - A severe bug fixed concerning the Daylight Saving Time - Dependency to POSIX.pm has been removed 0.5 Initial release Class-Date-1.1.15/Date.xs000644 000765 000024 00000030007 12330065506 015205 0ustar00gaborstaff000000 000000 /* * * Some functions (mini_mktime, strftime_xs) are borrowed from * Matt Sergeant's Time::Object module * * $Id: Date.xs,v b7a562a12fb9 2003/08/16 12:41:29 dlux $ * */ #ifdef __cplusplus #extern "C" { #endif #include "config.h" #include "EXTERN.h" #include "perl.h" #include "XSUB.h" #include /* These lines are borrowed from the perl #9823 patch */ /* Mac OSX does not include a definition of tzname in a .h file */ #if defined (HAS_TZNAME) && defined(__APPLE__) && defined(__MACH__) extern char *tzname[2]; #endif #define BUFFER_SIZE 254 char buffer[BUFFER_SIZE]; #if 0 #define CLASSDATE_TM_DEBUG(x) strftime(buffer, BUFFER_SIZE-1, "%Z", &x); \ printf("TZ: %5s, %4s,%4s, %02d:%02d:%02d, %02d-%02d-%03d %1d,%03d,%1d,%s:%s\n", \ getenv("TZ"), tzname[0], tzname[1], \ x.tm_sec, x.tm_min, x.tm_hour, x.tm_mday, x.tm_mon, x.tm_year, x.tm_wday, x.tm_yday,x.tm_isdst, \ asctime(&x), buffer) #else #define CLASSDATE_TM_DEBUG(x) #endif #ifdef __cplusplus } #endif /* XXX struct tm on some systems (SunOS4/BSD) contains extra (non POSIX) * fields for which we don't have Configure support yet: * char *tm_zone; -- abbreviation of timezone name * long tm_gmtoff; -- offset from GMT in seconds * To workaround core dumps from the uninitialised tm_zone we get the * system to give us a reasonable struct to copy. This fix means that * strftime uses the tm_zone and tm_gmtoff values returned by * localtime(time()). That should give the desired result most of the * time. But probably not always! * * This is a temporary workaround to be removed once Configure * support is added and NETaa14816 is considered in full. * It does not address tzname aspects of NETaa14816. */ #ifdef HAS_GNULIBC # ifndef STRUCT_TM_HASZONE # define STRUCT_TM_HASZONE # endif #endif /* * classdate_mini_mktime - normalise struct tm values without the localtime() * semantics (and overhead) of mktime(). */ static void classdate_mini_mktime(struct tm *ptm) { int yearday; int secs; int month, mday, year, jday; int odd_cent, odd_year; #define DAYS_PER_YEAR 365 #define DAYS_PER_QYEAR (4*DAYS_PER_YEAR+1) #define DAYS_PER_CENT (25*DAYS_PER_QYEAR-1) #define DAYS_PER_QCENT (4*DAYS_PER_CENT+1) #define SECS_PER_HOUR (60*60) #define SECS_PER_DAY (24*SECS_PER_HOUR) /* parentheses deliberately absent on these two, otherwise they don't work */ #define MONTH_TO_DAYS 153/5 #define DAYS_TO_MONTH 5/153 /* offset to bias by March (month 4) 1st between month/mday & year finding */ #define YEAR_ADJUST (4*MONTH_TO_DAYS+1) /* as used here, the algorithm leaves Sunday as day 1 unless we adjust it */ #define WEEKDAY_BIAS 6 /* (1+6)%7 makes Sunday 0 again */ /* * Year/day algorithm notes: * * With a suitable offset for numeric value of the month, one can find * an offset into the year by considering months to have 30.6 (153/5) days, * using integer arithmetic (i.e., with truncation). To avoid too much * messing about with leap days, we consider January and February to be * the 13th and 14th month of the previous year. After that transformation, * we need the month index we use to be high by 1 from 'normal human' usage, * so the month index values we use run from 4 through 15. * * Given that, and the rules for the Gregorian calendar (leap years are those * divisible by 4 unless also divisible by 100, when they must be divisible * by 400 instead), we can simply calculate the number of days since some * arbitrary 'beginning of time' by futzing with the (adjusted) year number, * the days we derive from our month index, and adding in the day of the * month. The value used here is not adjusted for the actual origin which * it normally would use (1 January A.D. 1), since we're not exposing it. * We're only building the value so we can turn around and get the * normalised values for the year, month, day-of-month, and day-of-year. * * For going backward, we need to bias the value we're using so that we find * the right year value. (Basically, we don't want the contribution of * March 1st to the number to apply while deriving the year). Having done * that, we 'count up' the contribution to the year number by accounting for * full quadracenturies (400-year periods) with their extra leap days, plus * the contribution from full centuries (to avoid counting in the lost leap * days), plus the contribution from full quad-years (to count in the normal * leap days), plus the leftover contribution from any non-leap years. * At this point, if we were working with an actual leap day, we'll have 0 * days left over. This is also true for March 1st, however. So, we have * to special-case that result, and (earlier) keep track of the 'odd' * century and year contributions. If we got 4 extra centuries in a qcent, * or 4 extra years in a qyear, then it's a leap day and we call it 29 Feb. * Otherwise, we add back in the earlier bias we removed (the 123 from * figuring in March 1st), find the month index (integer division by 30.6), * and the remainder is the day-of-month. We then have to convert back to * 'real' months (including fixing January and February from being 14/15 in * the previous year to being in the proper year). After that, to get * tm_yday, we work with the normalised year and get a new yearday value for * January 1st, which we subtract from the yearday value we had earlier, * representing the date we've re-built. This is done from January 1 * because tm_yday is 0-origin. * * Since POSIX time routines are only guaranteed to work for times since the * UNIX epoch (00:00:00 1 Jan 1970 UTC), the fact that this algorithm * applies Gregorian calendar rules even to dates before the 16th century * doesn't bother me. Besides, you'd need cultural context for a given * date to know whether it was Julian or Gregorian calendar, and that's * outside the scope for this routine. Since we convert back based on the * same rules we used to build the yearday, you'll only get strange results * for input which needed normalising, or for the 'odd' century years which * were leap years in the Julian calander but not in the Gregorian one. * I can live with that. * * This algorithm also fails to handle years before A.D. 1 gracefully, but * that's still outside the scope for POSIX time manipulation, so I don't * care. */ year = 1900 + ptm->tm_year; month = ptm->tm_mon; mday = ptm->tm_mday; /* allow given yday with no month & mday to dominate the result */ if (ptm->tm_yday >= 0 && mday <= 0 && month <= 0) { month = 0; mday = 0; jday = 1 + ptm->tm_yday; } else { jday = 0; } if (month >= 2) month+=2; else month+=14, year--; yearday = DAYS_PER_YEAR * year + year/4 - year/100 + year/400; yearday += month*MONTH_TO_DAYS + mday + jday; /* * Note that we don't know when leap-seconds were or will be, * so we have to trust the user if we get something which looks * like a sensible leap-second. Wild values for seconds will * be rationalised, however. */ if ((unsigned) ptm->tm_sec <= 60) { secs = 0; } else { secs = ptm->tm_sec; ptm->tm_sec = 0; } secs += 60 * ptm->tm_min; secs += SECS_PER_HOUR * ptm->tm_hour; if (secs < 0) { if (secs-(secs/SECS_PER_DAY*SECS_PER_DAY) < 0) { /* got negative remainder, but need positive time */ /* back off an extra day to compensate */ yearday += (secs/SECS_PER_DAY)-1; secs -= SECS_PER_DAY * (secs/SECS_PER_DAY - 1); } else { yearday += (secs/SECS_PER_DAY); secs -= SECS_PER_DAY * (secs/SECS_PER_DAY); } } else if (secs >= SECS_PER_DAY) { yearday += (secs/SECS_PER_DAY); secs %= SECS_PER_DAY; } ptm->tm_hour = secs/SECS_PER_HOUR; secs %= SECS_PER_HOUR; ptm->tm_min = secs/60; secs %= 60; ptm->tm_sec += secs; /* done with time of day effects */ /* * The algorithm for yearday has (so far) left it high by 428. * To avoid mistaking a legitimate Feb 29 as Mar 1, we need to * bias it by 123 while trying to figure out what year it * really represents. Even with this tweak, the reverse * translation fails for years before A.D. 0001. * It would still fail for Feb 29, but we catch that one below. */ jday = yearday; /* save for later fixup vis-a-vis Jan 1 */ yearday -= YEAR_ADJUST; year = (yearday / DAYS_PER_QCENT) * 400; yearday %= DAYS_PER_QCENT; odd_cent = yearday / DAYS_PER_CENT; year += odd_cent * 100; yearday %= DAYS_PER_CENT; year += (yearday / DAYS_PER_QYEAR) * 4; yearday %= DAYS_PER_QYEAR; odd_year = yearday / DAYS_PER_YEAR; year += odd_year; yearday %= DAYS_PER_YEAR; if (!yearday && (odd_cent==4 || odd_year==4)) { /* catch Feb 29 */ month = 1; yearday = 29; } else { yearday += YEAR_ADJUST; /* recover March 1st crock */ month = yearday*DAYS_TO_MONTH; yearday -= month*MONTH_TO_DAYS; /* recover other leap-year adjustment */ if (month > 13) { month-=14; year++; } else { month-=2; } } ptm->tm_year = year - 1900; if (yearday) { ptm->tm_mday = yearday; ptm->tm_mon = month; } else { ptm->tm_mday = 31; ptm->tm_mon = month - 1; } /* re-build yearday based on Jan 1 to get tm_yday */ year--; yearday = year*DAYS_PER_YEAR + year/4 - year/100 + year/400; yearday += 14*MONTH_TO_DAYS + 1; ptm->tm_yday = jday - yearday; /* fix tm_wday if not overridden by caller */ if ((unsigned)ptm->tm_wday > 6) ptm->tm_wday = (jday + WEEKDAY_BIAS) % 7; } MODULE = Class::Date PACKAGE = Class::Date void strftime_xs(fmt, sec, min, hour, mday, mon, year, wday = -1, yday = -1, isdst = -1) char * fmt int sec int min int hour int mday int mon int year int wday int yday int isdst PPCODE: { char tmpbuf[128]; struct tm mytm; int len; memset(&mytm, 0, sizeof(mytm)); mytm.tm_sec = sec; mytm.tm_min = min; mytm.tm_hour = hour; mytm.tm_mday = mday; mytm.tm_mon = mon; mytm.tm_year = year; mytm.tm_wday = wday; mytm.tm_yday = yday; mytm.tm_isdst = isdst; classdate_mini_mktime(&mytm); CLASSDATE_TM_DEBUG(mytm); len = strftime(tmpbuf, sizeof tmpbuf, fmt, &mytm); /* ** The following is needed to handle to the situation where ** tmpbuf overflows. Basically we want to allocate a buffer ** and try repeatedly. The reason why it is so complicated ** is that getting a return value of 0 from strftime can indicate ** one of the following: ** 1. buffer overflowed, ** 2. illegal conversion specifier, or ** 3. the format string specifies nothing to be returned(not ** an error). This could be because format is an empty string ** or it specifies %p that yields an empty string in some locale. ** If there is a better way to make it portable, go ahead by ** all means. */ if ((len > 0 && len < sizeof(tmpbuf)) || (len == 0 && *fmt == '\0')) ST(0) = sv_2mortal(newSVpv(tmpbuf, len)); else { /* Possibly buf overflowed - try again with a bigger buf */ int fmtlen = strlen(fmt); int bufsize = fmtlen + sizeof(tmpbuf); char* buf; int buflen; New(0, buf, bufsize, char); while (buf) { CLASSDATE_TM_DEBUG(mytm); buflen = strftime(buf, bufsize, fmt, &mytm); if (buflen > 0 && buflen < bufsize) break; /* heuristic to prevent out-of-memory errors */ if (bufsize > 100*fmtlen) { Safefree(buf); buf = NULL; break; } bufsize *= 2; Renew(buf, bufsize, char); } if (buf) { ST(0) = sv_2mortal(newSVpv(buf, buflen)); Safefree(buf); } else ST(0) = sv_2mortal(newSVpv(tmpbuf, len)); } } XSRETURN(1); MODULE = Class::Date PACKAGE = Class::Date void tzset_xs() CODE: tzset(); MODULE = Class::Date PACKAGE = Class::Date void tzname_xs() PPCODE: EXTEND(SP,2); PUSHs(sv_2mortal(newSVpv(tzname[0],0))); PUSHs(sv_2mortal(newSVpv(tzname[1],0))); XSRETURN(2); Class-Date-1.1.15/lib/000755 000765 000024 00000000000 12331601600 014512 5ustar00gaborstaff000000 000000 Class-Date-1.1.15/Makefile.PL000644 000765 000024 00000002342 12331600353 015723 0ustar00gaborstaff000000 000000 use ExtUtils::MakeMaker; # See lib/ExtUtils/MakeMaker.pm for details of how to influence # the contents of the Makefile that is written. use 5.006; WriteMakefile( NAME => 'Class::Date', VERSION_FROM => 'lib/Class/Date.pm', ABSTRACT_FROM => 'lib/Class/Date.pod', AUTHOR => 'Balazs Szabo (dLux)', LICENSE => 'perl', MIN_PERL_VERSION => 5.006, BUILD_REQUIRES => { 'Test::More' => '1.001', #'Env::C' => '0.06', # still conditional in the code, but let's try to require it. See also: RT #95332 'Scalar::Util' => '1.38', }, META_MERGE => { resources => { repository => 'http://code.google.com/p/perl-class-date/', }, x_contributors => [ 'dLux (Szabó, Balázs) ', 'Matt Sergeant ', 'Tatsuhiko Miyagawa ', 'Stas Bekman ', 'Chris Winters ', 'Benoit Beausejour ', 'Gabor Szabo ', ], }, # dist => { # PREOP => $^X.' -MPod::Text -e "pod2text(q(Date.pod))" > README' # } ) Class-Date-1.1.15/MANIFEST000644 000765 000024 00000000575 12331601600 015104 0ustar00gaborstaff000000 000000 Changes Date.xs lib/Class/Date.pm lib/Class/Date.pod lib/Class/Date/Const.pm lib/Class/Date/Invalid.pm lib/Class/Date/Rel.pm Makefile.PL MANIFEST This list of files META.yml README success.txt t/00_base.t t/05_parsing.t t/10_fields.t t/20_gmdate.t t/30_localdate.t t/40_errors.t t/50_timezone.t META.json Module JSON meta-data (added by MakeMaker) Class-Date-1.1.15/META.json000644 000765 000024 00000002522 12331601600 015366 0ustar00gaborstaff000000 000000 { "abstract" : "Class for easy date and time manipulation", "author" : [ "Balazs Szabo (dLux)" ], "dynamic_config" : 1, "generated_by" : "ExtUtils::MakeMaker version 6.66, CPAN::Meta::Converter version 2.133380", "license" : [ "perl_5" ], "meta-spec" : { "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec", "version" : "2" }, "name" : "Class-Date", "no_index" : { "directory" : [ "t", "inc" ] }, "prereqs" : { "build" : { "requires" : { "Scalar::Util" : "1.38", "Test::More" : "1.001" } }, "configure" : { "requires" : { "ExtUtils::MakeMaker" : "0" } }, "runtime" : { "requires" : { "perl" : "5.006" } } }, "release_status" : "stable", "resources" : { "repository" : { "url" : "http://code.google.com/p/perl-class-date/" } }, "version" : "v1.1.15", "x_contributors" : [ "dLux (Szabó, Balázs) ", "Matt Sergeant ", "Tatsuhiko Miyagawa ", "Stas Bekman ", "Chris Winters ", "Benoit Beausejour ", "Gabor Szabo " ] } Class-Date-1.1.15/META.yml000644 000765 000024 00000001552 12331601600 015220 0ustar00gaborstaff000000 000000 --- abstract: 'Class for easy date and time manipulation' author: - 'Balazs Szabo (dLux)' build_requires: Scalar::Util: 1.38 Test::More: 1.001 configure_requires: ExtUtils::MakeMaker: 0 dynamic_config: 1 generated_by: 'ExtUtils::MakeMaker version 6.66, CPAN::Meta::Converter version 2.133380' license: perl meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: 1.4 name: Class-Date no_index: directory: - t - inc requires: perl: 5.006 resources: repository: http://code.google.com/p/perl-class-date/ version: v1.1.15 x_contributors: - 'dLux (Szabó, Balázs) ' - 'Matt Sergeant ' - 'Tatsuhiko Miyagawa ' - 'Stas Bekman ' - 'Chris Winters ' - 'Benoit Beausejour ' - 'Gabor Szabo ' Class-Date-1.1.15/README000644 000765 000024 00000000236 12331120702 014624 0ustar00gaborstaff000000 000000 Class::Date - Class for easy date and time manipulation For details see https://metacpan.org/pod/Class::Date Or http://search.cpan.org/perldoc?Class::Date Class-Date-1.1.15/success.txt000644 000765 000024 00000000124 12330072115 016154 0ustar00gaborstaff000000 000000 - SUSE package - FreeBSD port - OpenBSD port - P5EEx Perl in Enterprise Environment Class-Date-1.1.15/t/000755 000765 000024 00000000000 12331601600 014207 5ustar00gaborstaff000000 000000 Class-Date-1.1.15/t/00_base.t000644 000765 000024 00000000446 12330531160 015613 0ustar00gaborstaff000000 000000 use strict; use warnings; use Test::More; plan tests => 6; use Class::Date qw(now gmdate); ok(1); my $t = gmdate(315532800); # 00:00:00 1/1/1980 is $t->year, 1980, 'year'; is $t->hour, 0, 'hour'; is $t->mon, 1, 'mon'; cmp_ok now, '>', "1970-1-1"; cmp_ok gmdate("now"), '>', "1970-1-1"; Class-Date-1.1.15/t/05_parsing.t000644 000765 000024 00000000452 12330531443 016352 0ustar00gaborstaff000000 000000 use strict; use warnings; use Test::More; plan tests => 7; use Class::Date qw(gmdate); ok(1); my $t = gmdate("2008-8-3T11:7:10"); is $t->year, 2008, 'year'; is $t->month, 8, 'month'; is $t->day, 3, 'day'; is $t->hour, 11, 'hour'; is $t->min, 7, 'min'; is $t->second, 10, 'second'; Class-Date-1.1.15/t/10_fields.t000755 000765 000024 00000001677 12330531543 016167 0ustar00gaborstaff000000 000000 use strict; use warnings; use Test::More; plan tests => 18; use Class::Date qw(gmdate); ok(1); my $t = gmdate("2001-07-26 16:15:23"); is $t->set(year => 2002), "2002-07-26 16:15:23"; is $t,"2001-07-26 16:15:23"; is $t->set(_year => 105), "2005-07-26 16:15:23"; is $t,"2001-07-26 16:15:23"; is $t->set(month => 4), "2001-04-26 16:15:23"; is $t->set(mon => 9), "2001-09-26 16:15:23"; is $t->set(_month=> 7), "2001-08-26 16:15:23"; is $t->set(_mon => 2), "2001-03-26 16:15:23"; is $t->set(day => 12), "2001-07-12 16:15:23"; is $t->set(mday => 21), "2001-07-21 16:15:23"; is $t->set(day_of_month=>5), "2001-07-05 16:15:23"; is $t->set(hour => 14), "2001-07-26 14:15:23"; is $t->set(min => 34), "2001-07-26 16:34:23"; is $t->set(minute=> 19), "2001-07-26 16:19:23"; is $t->set(sec => 49), "2001-07-26 16:15:49"; is $t->set(second=> 44), "2001-07-26 16:15:44"; is $t->set(year => 1985, day => 16), "1985-07-16 16:15:23"; Class-Date-1.1.15/t/20_gmdate.t000755 000765 000024 00000006226 12330532362 016156 0ustar00gaborstaff000000 000000 use strict; use warnings; use Test::More; plan tests => 56; use Class::Date qw(gmdate date); $Class::Date::DST_ADJUST=1; ok(1); # Class::Date::new my $date1=gmdate([2000,11,11,0,1,2]); is$date1,"2000-11-11 00:01:02"; my $date2=date [2000,10,5],1; is $date2,"2000-10-05 00:00:00"; my $date3=gmdate({ year => 2001, month => 03, day => 11, hour => 12, min => 13, sec => 55 }); is $date3,"2001-03-11 12:13:55"; my $date4=gmdate({ year => 2001, month => 03, day => 11 }); is $date4,"2001-03-11 00:00:00"; my $date5=gmdate("2001-2-21 13:11:10.123456"); is $date5,"2001-02-21 13:11:10"; my $date6=gmdate("2001-2-21 13:11:06"); is $date6,"2001-02-21 13:11:06"; my $date7=gmdate("973897200"); is $date7,"2000-11-10 23:00:00"; my $date8=gmdate("2001011312220112"); is $date8,"2001-01-13 12:22:01"; my $date9=gmdate("2001-5-11"); is $date9,"2001-05-11 00:00:00"; my $date10=$date9->new($date9); is $date10,"2001-05-11"; # Class::Date::Rel::new my $reldate1=Class::Date::Rel->new('1D'); is $reldate1,"0000-00-01 00:00:00"; my $reldate2=Class::Date::Rel->new('1Y 1M 15h 20m'); is $reldate2,"0001-01-00 15:20:00"; my $reldate3=Class::Date::Rel->new('3Y 3M 5D 13h 20m 15s'); is $reldate3,"0003-03-05 13:20:15"; my $reldate4=Class::Date::Rel->new({ year => 5, day => 7}); is $reldate4,"0005-00-07 00:00:00"; my $reldate5=Class::Date::Rel->new({ year => 9, month => 8, day => 7, hour => 6, min => 65, sec => 55, }); is $reldate5,"0009-08-07 07:05:55"; my $reldate6=Class::Date::Rel->new([9,8,7,6,65,55]); is $reldate6,"0009-08-07 07:05:55"; my $reldate7=Class::Date::Rel->new("7-8-6 07:11:10"); is $reldate7,"0007-08-06 07:11:10"; my $reldate8=$reldate5->new($reldate7); is $reldate8,"7Y 8M 6D 7h 11m 10s"; # Class::Date::add is $date1+$reldate1,"2000-11-12 00:01:02"; is $date7+$reldate3,"2004-02-16 12:20:15"; is $date1+"2Y","2002-11-11 00:01:02"; is $date1+"2-0-0","2002-11-11 00:01:02"; # Class::Date::subs is $date1-$reldate1,"2000-11-10 00:01:02"; is $date7-$reldate3+$reldate3,$date7; is $date3-$date1,'120D 12h 12m 53s'; # Class::Date Comparison cmp_ok $date1, '>', $date2; cmp_ok $date1, '>=', $date1; ok ! ($date1<"2000-01-01"); ok ! ("2000-01-01">$date1); is "2000-01-02" <=> $date1, -1; is "2001-01-02" cmp $date1, 1 ; is $date1 <=> "2000-01-02", 1; is $date1 cmp "2001-01-02", -1; # Class::Date::Rel Comparison cmp_ok $reldate1, '<', $reldate2; cmp_ok $reldate2, '<', '2Y'; cmp_ok '2Y', '<', $reldate3; is '2Y' <=> $reldate3, -1; is $reldate3 <=> '2Y', 1; # Class::Date field methods; is $date1->year, 2000; is $date1->mon, 11; is $date1->mday, 11; is $date1->hour, 0; is $date1->min, 1; is $date1->sec, 2; # Default values for hash initialization my $date11 = Class::Date->new( { year => 2001 } ); is $date11,"2001-01-01 00:00:00"; my $date12 = Class::Date->new( { month => 2 } ); is $date12,"2000-02-01 00:00:00"; my $date13 = gmdate [1998]; is $date13,"1998-01-01"; my $reldate9 = Class::Date::Rel->new( { year => 4 }); is $reldate9, "4-0-0 0:0:0"; my $reldate10 = Class::Date::Rel->new( { month => 5 }); is $reldate10, "0-5-0 0:0:0"; my ($y,$m,$d,$hh,$mm,$ss)=$date1->array; is $y, 2000; is $m, 11; is $d, 11; is $hh, 0; is $mm, 1; is $ss, 2; Class-Date-1.1.15/t/30_localdate.t000755 000765 000024 00000010223 12330625141 016634 0ustar00gaborstaff000000 000000 use strict; use warnings; use Test::More; plan tests => 77; use Class::Date qw(localdate date); $Class::Date::DST_ADJUST=1; ok(1); # Class::Date::new my $date1 = Class::Date->new([2000,11,11,0,1,2]); is $date1, "2000-11-11 00:01:02"; my $date2 = localdate [2000,10,5]; is $date2, "2000-10-05 00:00:00"; my $date3 = date({ year => 2001, month => 03, day => 11, hour => 12, min => 13, sec => 55 }); is $date3, "2001-03-11 12:13:55"; my $date4 = localdate({ year => 2001, month => 03, day => 11 }); is $date4, "2001-03-11 00:00:00"; my $date5 = localdate("2001-2-21 13:11:10.123456"); is $date5, "2001-02-21 13:11:10"; my $date6 = localdate("2001-2-21 13:11"); is $date6, "2001-02-21 13:11"; my $date7 = localdate("2000-11-11 0:0:0"); is $date7, "2000-11-11"; my $date8 = localdate("2001011312220112"); is $date8, "2001-01-13 12:22:01"; my $date9 = localdate("2001-5-11"); is $date9, "2001-05-11 00:00:00"; my $date10 = $date9->new($date9); is $date10, "2001-05-11"; # Class::Date::Rel::new my $reldate1 = Class::Date::Rel->new('1D'); is $reldate1, "0000-00-01 00:00:00"; my $reldate2 = Class::Date::Rel->new('1Y 1M 15h 20m'); is $reldate2, "0001-01-00 15:20"; my $reldate3 = Class::Date::Rel->new('3Y 3M 5D 13h 20m 15s'); is $reldate3, "0003-03-05 13:20:15"; my $reldate4 = Class::Date::Rel->new({ year => 5, day => 7}); is $reldate4, "0005-00-07 00:00:00"; my $reldate5 = Class::Date::Rel->new({ year => 9, month => 8, day => 7, hour => 6, min => 65, sec => 55, }); is $reldate5, "0009-08-07 07:05:55"; my $reldate6 = Class::Date::Rel->new([9,8,7,6,65,55]); is $reldate6, "0009-08-07 07:05:55"; my $reldate7 = Class::Date::Rel->new("7-8-6 07:11:10"); is $reldate7, "0007-08-06 07:11:10"; my $reldate8 = $reldate5->new($reldate7); is $reldate8, "7Y 8M 6D 7h 11m 10s"; # Class::Date::add is $date1+$reldate1, "2000-11-12 00:01:02"; is $date7+$reldate3, "2004-02-16 13:20:15"; is $date1+"2Y", "2002-11-11 00:01:02"; is $date1+"2-0-0", "2002-11-11 00:01:02"; # Class::Date::subs is $date1-$reldate1, "2000-11-10 00:01:02"; is $date7-$reldate3+$reldate3, $date7; is $date3-$date1, '120D 12h 12m 53s'; is $date1-'1D', "2000-11-10 0:1:2"; is $date1-[0,0,1], "2000-11-10 0:1:2"; # Class::Date Comparison ok $date1 > $date2; ok $date1 >= $date1; ok ! ($date1<"2000-01-01"); ok ! ("2000-01-01">$date1); is "2000-01-02" <=> $date1, -1; is "2001-01-02" cmp $date1, 1 ; is $date1 <=> "2000-01-02", 1; is $date1 cmp "2001-01-02", -1; # Class::Date::Rel Comparison ok $reldate1 < $reldate2; ok $reldate2 < '2Y'; ok '2Y' < $reldate3; is '2Y' <=> $reldate3, -1; is $reldate3 <=> '2Y', 1; # Class::Date field methods; is $date1->year, 2000; is $date1->mon, 11; is $date1->day, 11; is $date1->hour, 0; is $date1->min, 1; is $date1->sec, 2; # Default values for hash initialization my $date11 = Class::Date->new({ year => 2001 }); is $date11, "2001-01-01 00:00:00"; my $date12 = new Class::Date { month => 2 }; is $date12, "2000-02-01 00:00:00"; my $date13 = localdate [1998]; is $date13, "1998-01-01"; my $reldate9 = Class::Date::Rel->new( { year => 4 }); is $reldate9, "4-0-0 0:0:0"; my $reldate10 = Class::Date::Rel->new( { month => 5 }); is $reldate10, "0-5-0 0:0:0"; my ($y,$m,$d,$hh,$mm,$ss) = $date1->array; is $y, 2000; is $m, 11; is $d, 11; is $hh, 0; is $mm, 1; is $ss, 2; # undef comparison ok $date11 > undef() ? 1 : 0; ok undef() > $date11 ? 0 : 1; ok $date13 < undef() ? 0 : 1; ok undef() < $date13 ? 1 : 0; is $date1->month_begin, "2000-11-01 00:01:02"; is $date1->month_end , "2000-11-30 00:01:02"; is $date1->days_in_month, 30; is $date2->days_in_month,31; is $date5->days_in_month,28; is $date1->truncate, "2000-11-11 00:00:00"; is $date1->trunc, "2000-11-11 00:00:00"; is $date1, "2000-11-11 00:01:02"; { local $Class::Date::MONTH_BORDER_ADJUST = 0; my $date11 = date("2001-05-31"); is $date11+'4M', "2001-10-01"; is $date11-'3M', "2001-03-03"; $Class::Date::MONTH_BORDER_ADJUST = 1; is $date11+'4M', "2001-09-30"; is $date11-'3M', "2001-02-28"; } my $date14 = date("2001-12-18"); is $date14->days_in_month, 31; is date([2001,11,17])->is_leap_year ? 1 : 0, 0; is date([2004,03,05])->is_leap_year ? 1 : 0, 1; Class-Date-1.1.15/t/40_errors.t000755 000765 000024 00000001454 12330625317 016234 0ustar00gaborstaff000000 000000 use strict; use warnings; use Test::More; plan tests => 18; use Class::Date qw(:errors gmdate); $Class::Date::DST_ADJUST=1; ok(1); my $t = gmdate("195xwerf9"); ok !$t; is $t->error, E_UNPARSABLE; is $t->errstr, "Unparsable date or time: 195xwerf9\n"; $Class::Date::RANGE_CHECK=0; $t = gmdate("2001-02-31"); is $t, "2001-03-03"; $Class::Date::RANGE_CHECK=1; $t = gmdate("2001-02-31"); ok !$t; ok $t ? 0 : 1; is $t->error, E_RANGE; is $t->errstr, "Range check on date or time failed\n"; $t = gmdate("2006-2-6")->clone( month => -1); ok !$t; ok $t ? 0 : 1; $t = new Class::Date(undef); ok ! $t; ok $t ? 0 : 1; is $t->error, E_UNDEFINED; is $t->errstr, "Undefined date object\n"; $t = gmdate("2006-2-6")->clone(month => 16); ok !$t; ok $t ? 0 : 1; $t = gmdate("2001-05-04 07:09:09") + [1,-2,-4]; ok $t; Class-Date-1.1.15/t/50_timezone.t000755 000765 000024 00000003014 12331111762 016540 0ustar00gaborstaff000000 000000 use strict; use warnings; use Test::More; plan tests => 11; use Class::Date qw(date gmdate); eval { require Env::C }; diag "Env::C version $Env::C::VERSION loaded" if not $@; $Class::Date::DST_ADJUST=1; ok(1); # Class::Date::new my $date1 = Class::Date->new([2002,05,04,0,1,2],'CET'); is $date1, "2002-05-04 00:01:02", 'date1'; is $date1->tz, 'CET', 'tz'; is $date1->tzdst, 'CEST', 'tzdst'; is $date1->epoch, 1020463262, 'epoch'; my $date2 = $date1->to_tz('GMT'); is $date2, "2002-05-03 22:01:02", 'date2'; is $date2->tz, 'GMT', 'tz'; is $date2->tzdst, 'GMT', 'tzdst'; is $date1->epoch, 1020463262, 'epoch'; my $date3 = $date1->clone(tz => 'GMT'); is $date3->epoch, 1020470462, 'epoch'; is $date3, gmdate([2002,05,04,0,1,2]), 'gmdate'; # RT 23998 my $dt = date("2006-06-24 05:23:42", "CET"); #diag $dt->to_tz("GMT")->strftime("%Y-%m-%d %H:%M:%S%z"); #diag $dt->strftime("%Y-%m-%d %H:%M:%S%z"); # bug reports this output: # 2006-06-24 03:23:42+0000 # 2006-06-24 05:23:42+0000 # actual output on OSX: # 2006-06-24 03:23:42+0000 # 2006-06-24 05:23:42+0200 #subtest rt_23998_comment => sub { # plan tests => 2; # my $dt1 = date("2006-06-24 05:23:42 +0400"); # is $dt1->to_tz("GMT")->strftime("%Y-%m-%d %H:%M:%S%z"), '2006-06-24 01:23:42+0000', 'to_tz +0400'; # # bug reports 2006-06-24 03:23:42+0000 # # my $dt2 = date("2006-06-24 05:23:42 +0400", "GMT-4"); # is $dt2->to_tz("GMT")->strftime("%Y-%m-%d %H:%M:%S%z"), '2006-06-24 01:23:42+0000', 'to_tz GMT-4'; #}; Class-Date-1.1.15/lib/Class/000755 000765 000024 00000000000 12331601600 015557 5ustar00gaborstaff000000 000000 Class-Date-1.1.15/lib/Class/Date/000755 000765 000024 00000000000 12331601600 016434 5ustar00gaborstaff000000 000000 Class-Date-1.1.15/lib/Class/Date.pm000644 000765 000024 00000040642 12331601561 017006 0ustar00gaborstaff000000 000000 package Class::Date; # $Id: Date.pm,v 8dbcc6b6035d 2008/11/23 00:41:11 dlux $ use 5.006; use strict; use vars qw( @EXPORT_OK %EXPORT_TAGS @ISA $DATE_FORMAT $DST_ADJUST $MONTH_BORDER_ADJUST $RANGE_CHECK @NEW_FROM_SCALAR @ERROR_MESSAGES $WARNINGS $DEFAULT_TIMEZONE $LOCAL_TIMEZONE $GMT_TIMEZONE $NOTZ_TIMEZONE $RESTORE_TZ ); use Carp; use Exporter; use DynaLoader; use Time::Local; use Class::Date::Const; use Scalar::Util qw(blessed); use Class::Date::Rel; use Class::Date::Invalid; BEGIN { $WARNINGS = 1 if !defined $WARNINGS; if ($] > 5.006) { *timelocal = *Time::Local::timelocal_nocheck; *timegm = *Time::Local::timegm_nocheck; } else { *timelocal = *Time::Local::timelocal; *timegm = *Time::Local::timegm; } @ISA=qw(DynaLoader Exporter); %EXPORT_TAGS = ( errors => $Class::Date::Const::EXPORT_TAGS{errors}); @EXPORT_OK = (qw( date localdate gmdate now @ERROR_MESSAGES), @{$EXPORT_TAGS{errors}}); our $VERSION = '1.1.15'; eval { Class::Date->bootstrap($VERSION); }; if ($@) { warn "Cannot find the XS part of Class::Date, \n". " using strftime, tzset and tzname from POSIX module.\n" if $WARNINGS; require POSIX; *strftime_xs = *POSIX::strftime; *tzset_xs = *POSIX::tzset; *tzname_xs = *POSIX::tzname; } } $GMT_TIMEZONE = 'GMT'; $DST_ADJUST = 1; $MONTH_BORDER_ADJUST = 0; $RANGE_CHECK = 0; $RESTORE_TZ = 1; $DATE_FORMAT="%Y-%m-%d %H:%M:%S"; sub _set_tz { my ($tz) = @_; my $lasttz = $ENV{TZ}; if (!defined $tz || $tz eq $NOTZ_TIMEZONE) { # warn "_set_tz: deleting TZ\n"; delete $ENV{TZ}; Env::C::unsetenv('TZ') if exists $INC{"Env/C.pm"}; } else { # warn "_set_tz: setting TZ to $tz\n"; $ENV{TZ} = $tz; Env::C::setenv('TZ', $tz) if exists $INC{"Env/C.pm"}; } tzset_xs(); return $lasttz; } sub _set_temp_tz { my ($tz, $sub) = @_; my $lasttz = _set_tz($tz); my $retval = eval { $sub->(); }; _set_tz($lasttz) if $RESTORE_TZ; die $@ if $@; return $retval; } tzset_xs(); $LOCAL_TIMEZONE = $DEFAULT_TIMEZONE = local_timezone(); { my $last_tz = _set_tz(undef); $NOTZ_TIMEZONE = local_timezone(); _set_tz($last_tz); } # warn "LOCAL: $LOCAL_TIMEZONE, NOTZ: $NOTZ_TIMEZONE\n"; # this method is used to determine what is the package name of the relative # time class. It is used at the operators. You only need to redefine it if # you want to derive both Class::Date and Class::Date::Rel. # Look at the Class::Date::Rel::ClassDate also. use constant ClassDateRel => "Class::Date::Rel"; use constant ClassDateInvalid => "Class::Date::Invalid"; use overload '""' => "string", '-' => "subtract", '+' => "add", '<=>' => "compare", 'cmp' => "compare", fallback => 1; sub date ($;$) { my ($date,$tz)=@_; return __PACKAGE__ -> new($date,$tz); } sub now () { date(time); } sub localdate ($) { date($_[0] || time, $LOCAL_TIMEZONE) } sub gmdate ($) { date($_[0] || time, $GMT_TIMEZONE) } sub import { my $package=shift; my @exported; foreach my $symbol (@_) { if ($symbol eq '-DateParse') { if (!$Class::Date::DateParse++) { if ( eval { require Date::Parse } ) { push @NEW_FROM_SCALAR,\&new_from_scalar_date_parse; } else { warn "Date::Parse is not available, although it is requested by Class::Date\n" if $WARNINGS; } } } elsif ($symbol eq '-EnvC') { if (!$Class::Date::EnvC++) { if ( !eval { require Env::C } ) { warn "Env::C is not available, although it is requested by Class::Date\n" if $WARNINGS; } } } else { push @exported,$symbol; } }; $package->export_to_level(1,$package,@exported); } sub new { my ($proto,$time,$tz)=@_; my $class = ref($proto) || $proto; # if the prototype is an object, not a class, then the timezone will be # the same $tz = $proto->[c_tz] if defined($time) && !defined $tz && blessed($proto) && $proto->isa( __PACKAGE__ ); # Default timezone is used if the timezone cannot be determined otherwise $tz = $DEFAULT_TIMEZONE if !defined $tz; return $proto->new_invalid(E_UNDEFINED,"") if !defined $time; if (blessed($time) && $time->isa( __PACKAGE__ ) ) { return $class->new_copy($time,$tz); } elsif (blessed($time) && $time->isa('Class::Date::Rel')) { return $class->new_from_scalar($time,$tz); } elsif (ref($time) eq 'ARRAY') { return $class->new_from_array($time,$tz); } elsif (ref($time) eq 'SCALAR') { return $class->new_from_scalar($$time,$tz); } elsif (ref($time) eq 'HASH') { return $class->new_from_hash($time,$tz); } else { return $class->new_from_scalar($time,$tz); } } sub new_copy { my ($s,$input,$tz)=@_; my $new_object=[ @$input ]; # we don't mind $isgmt! return bless($new_object, ref($s) || $s); } sub new_from_array { my ($s,$time,$tz) = @_; my ($y,$m,$d,$hh,$mm,$ss,$dst) = @$time; my $obj= [ ($y||2000)-1900, ($m||1)-1, $d||1, $hh||0 , $mm||0 , $ss||0 ]; $obj->[c_tz]=$tz; bless $obj, ref($s) || $s; $obj->_recalc_from_struct; return $obj; } sub new_from_hash { my ($s,$time,$tz) = @_; $s->new_from_array(_array_from_hash($time),$tz); } sub _array_from_hash { my ($val)=@_; [ $val->{year} || ($val->{_year} ? $val->{_year} + 1900 : 0 ), $val->{mon} || $val->{month} || ( $val->{_mon} ? $val->{_mon} + 1 : 0 ), $val->{day} || $val->{mday} || $val->{day_of_month}, $val->{hour}, exists $val->{min} ? $val->{min} : $val->{minute}, exists $val->{sec} ? $val->{sec} : $val->{second}, ]; } sub new_from_scalar { my ($s,$time,$tz)=@_; for (my $i=0;$i<@NEW_FROM_SCALAR;$i++) { my $ret=$NEW_FROM_SCALAR[$i]->($s,$time,$tz); return $ret if defined $ret; } return $s->new_invalid(E_UNPARSABLE,$time); } sub new_from_scalar_internal { my ($s,$time,$tz) = @_; return undef if !$time; if ($time eq 'now') { # now string my $obj=bless [], ref($s) || $s; $obj->[c_epoch]=time; $obj->[c_tz]=$tz; $obj->_recalc_from_epoch; return $obj; } elsif ($time =~ /^\s*(\d{4})(\d\d)(\d\d)(\d\d)(\d\d)(\d\d)\d*\s*$/) { # mysql timestamp my ($y,$m,$d,$hh,$mm,$ss)=($1,$2,$3,$4,$5,$6); return $s->new_from_array([$y,$m,$d,$hh,$mm,$ss],$tz); } elsif ($time =~ /^\s*( \-? \d+ (\.\d+ )? )\s*$/x) { # epoch secs my $obj=bless [], ref($s) || $s; $obj->[c_epoch]=$1; $obj->[c_tz]=$tz; $obj->_recalc_from_epoch; return $obj; } elsif ($time =~ m{ ^\s* ( \d{0,4} ) - ( \d\d? ) - ( \d\d? ) ( (?: T|\s+ ) ( \d\d? ) : ( \d\d? ) ( : ( \d\d? ) (\.\d+)?)? )? }x) { my ($y,$m,$d,$hh,$mm,$ss)=($1,$2,$3,$5,$6,$8); # ISO(-like) date return $s->new_from_array([$y,$m,$d,$hh,$mm,$ss],$tz); } else { return undef; } } push @NEW_FROM_SCALAR,\&new_from_scalar_internal; sub new_from_scalar_date_parse { my ($s,$date,$tz)=@_; my $lt; my ($ss, $mm, $hh, $day, $month, $year, $zone) = Date::Parse::strptime($date); $zone = $tz if !defined $zone; if ($zone eq $GMT_TIMEZONE) { _set_temp_tz($zone, sub { $ss = ($lt ||= [ gmtime ])->[0] if !defined $ss; $mm = ($lt ||= [ gmtime ])->[1] if !defined $mm; $hh = ($lt ||= [ gmtime ])->[2] if !defined $hh; $day = ($lt ||= [ gmtime ])->[3] if !defined $day; $month = ($lt ||= [ gmtime ])->[4] if !defined $month; $year = ($lt ||= [ gmtime ])->[5] if !defined $year; }); } else { _set_temp_tz($zone, sub { $ss = ($lt ||= [ localtime ])->[0] if !defined $ss; $mm = ($lt ||= [ localtime ])->[1] if !defined $mm; $hh = ($lt ||= [ localtime ])->[2] if !defined $hh; $day = ($lt ||= [ localtime ])->[3] if !defined $day; $month = ($lt ||= [ localtime ])->[4] if !defined $month; $year = ($lt ||= [ localtime ])->[5] if !defined $year; }); } return $s->new_from_array( [$year+1900, $month+1, $day, $hh, $mm, $ss], $zone); } sub _check_sum { my ($s) = @_; my $sum=0; $sum += $_ || 0 foreach @{$s}[c_year .. c_sec]; return $sum; } sub _recalc_from_struct { my $s = shift; $s->[c_isdst] = -1; $s->[c_wday] = 0; $s->[c_yday] = 0; $s->[c_epoch] = 0; # these are required to suppress warinngs; eval { local $SIG{__WARN__} = sub { }; my $timecalc = $s->[c_tz] eq $GMT_TIMEZONE ? \&timegm : \&timelocal; _set_temp_tz($s->[c_tz], sub { $s->[c_epoch] = $timecalc->( @{$s}[c_sec,c_min,c_hour,c_day,c_mon], $s->[c_year] + 1900); } ); }; return $s->_set_invalid(E_INVALID,$@) if $@; my $sum = $s->_check_sum; $s->_recalc_from_epoch; @$s[c_error,c_errmsg] = (($s->_check_sum != $sum ? E_RANGE : 0), ""); return $s->_set_invalid(E_RANGE,"") if $RANGE_CHECK && $s->[c_error]; return 1; } sub _recalc_from_epoch { my ($s) = @_; _set_temp_tz($s->[c_tz], sub { @{$s}[c_year..c_isdst] = ($s->[c_tz] eq $GMT_TIMEZONE ? gmtime($s->[c_epoch]) : localtime($s->[c_epoch])) [5,4,3,2,1,0,6,7,8]; } ) } my $SETHASH = { year => sub { shift->[c_year] = shift() - 1900 }, _year => sub { shift->[c_year] = shift }, month => sub { shift->[c_mon] = shift() - 1 }, _month => sub { shift->[c_mon] = shift }, day => sub { shift->[c_day] = shift }, hour => sub { shift->[c_hour] = shift }, min => sub { shift->[c_min] = shift }, sec => sub { shift->[c_sec] = shift }, tz => sub { shift->[c_tz] = shift }, }; $SETHASH->{mon} = $SETHASH->{month}; $SETHASH->{_mon} = $SETHASH->{_month}; $SETHASH->{mday} = $SETHASH->{day_of_month} = $SETHASH->{day}; $SETHASH->{minute} = $SETHASH->{min}; $SETHASH->{second} = $SETHASH->{sec}; sub clone { my $s = shift; my $new_date = $s->new_copy($s); while (@_) { my $key = shift; my $value = shift; $SETHASH->{$key}->($value,$new_date); }; $new_date->_recalc_from_struct; return $new_date; } *set = *clone; # compatibility sub year { shift->[c_year] +1900 } sub _year { shift->[c_year] } sub yr { shift->[c_year] % 100 } sub mon { shift->[c_mon] +1 } *month = *mon; sub _mon { shift->[c_mon] } *_month = *_mon; sub day { shift->[c_day] } *day_of_month= *mday = *day; sub hour { shift->[c_hour] } sub min { shift->[c_min] } *minute = *min; sub sec { shift->[c_sec] } *second = *sec; sub wday { shift->[c_wday] + 1 } sub _wday { shift->[c_wday] } *day_of_week = *_wday; sub yday { shift->[c_yday] } *day_of_year = *yday; sub isdst { shift->[c_isdst] } *daylight_savings = \&isdst; sub epoch { shift->[c_epoch] } *as_sec = *epoch; # for compatibility sub tz { shift->[c_tz] } sub tzdst { shift->strftime("%Z") } sub monname { shift->strftime('%B') } *monthname = *monname; sub wdayname { shift->strftime('%A') } *day_of_weekname= *wdayname; sub error { shift->[c_error] } sub errmsg { my ($s) = @_; sprintf $ERROR_MESSAGES[ $s->[c_error] ]."\n", $s->[c_errmsg] } *errstr = *errmsg; sub new_invalid { my ($proto,$error,$errmsg) = @_; bless([],ref($proto) || $proto)->_set_invalid($error,$errmsg); } sub _set_invalid { my ($s,$error,$errmsg) = @_; bless($s,$s->ClassDateInvalid); @$s = (); @$s[ci_error, ci_errmsg] = ($error,$errmsg); return $s; } sub ampm { my ($s) = @_; return $s->[c_hour] < 12 ? "AM" : "PM"; } sub meridiam { my ($s) = @_; my $hour = $s->[c_hour] % 12; if( $hour == 0 ) { $hour = 12; } sprintf('%02d:%02d %s', $hour, $s->[c_min], $s->ampm); } sub hms { sprintf('%02d:%02d:%02d', @{ shift() }[c_hour,c_min,c_sec]) } sub ymd { my ($s)=@_; sprintf('%04d/%02d/%02d', $s->year, $s->mon, $s->[c_day]) } sub mdy { my ($s)=@_; sprintf('%02d/%02d/%04d', $s->mon, $s->[c_day], $s->year) } sub dmy { my ($s)=@_; sprintf('%02d/%02d/%04d', $s->[c_day], $s->mon, $s->year) } sub array { my ($s)=@_; my @return=@{$s}[c_year .. c_sec]; $return[c_year]+=1900; $return[c_mon]+=1; @return; } sub aref { return [ shift()->array ] } *as_array = *aref; sub struct { return ( @{ shift() } [c_sec,c_min,c_hour,c_day,c_mon,c_year,c_wday,c_yday,c_isdst] ) } sub sref { return [ shift()->struct ] } sub href { my ($s)=@_; my @struct=$s->struct; my $h={}; foreach my $key (qw(sec min hour day _month _year wday yday isdst)) { $h->{$key}=shift @struct; } $h->{epoch} = $s->[c_epoch]; $h->{year} = 1900 + $h->{_year}; $h->{month} = $h->{_month} + 1; $h->{minute} = $h->{min}; return $h; } *as_hash=*href; sub hash { return %{ shift->href } } # Thanks to Tony Olekshy for this algorithm # ripped from Time::Object by Matt Sergeant sub tzoffset { my ($s)=@_; my $epoch = $s->[c_epoch]; my $j = sub { # Tweaked Julian day number algorithm. my ($s,$n,$h,$d,$m,$y) = @_; $m += 1; $y += 1900; # Standard Julian day number algorithm without constant. my $y1 = $m > 2 ? $y : $y - 1; my $m1 = $m > 2 ? $m + 1 : $m + 13; my $day = int(365.25 * $y1) + int(30.6001 * $m1) + $d; # Modify to include hours/mins/secs in floating portion. return $day + ($h + ($n + $s / 60) / 60) / 24; }; # Compute floating offset in hours. my $delta = _set_temp_tz($s->[c_tz], sub { 24 * (&$j(localtime $epoch) - &$j(gmtime $epoch)); } ); # Return value in seconds rounded to nearest minute. return int($delta * 60 + ($delta >= 0 ? 0.5 : -0.5)) * 60; } sub month_begin { my ($s) = @_; my $aref = $s->aref; $aref->[2] = 1; return $s->new($aref); } sub month_end { my ($s)=@_; return $s->clone(day => 1)+'1M'-'1D'; } sub days_in_month { shift->month_end->mday; } sub is_leap_year { my ($s) = @_; my $new_date; eval { $new_date = $s->new([$s->year, 2, 29],$s->tz); } or return 0; return $new_date->day == 29; } sub strftime { my ($s,$format)=@_; $format ||= "%a, %d %b %Y %H:%M:%S %Z"; my $fmt = _set_temp_tz($s->[c_tz], sub { strftime_xs($format,$s->struct) } ); return $fmt; } sub string { my ($s) = @_; $s->strftime($DATE_FORMAT); } sub subtract { my ($s,$rhs)=@_; if (blessed($rhs) && $rhs->isa( __PACKAGE__ )) { my $dst_adjust = 0; $dst_adjust = 60*60*( $s->[c_isdst]-$rhs->[c_isdst] ) if $DST_ADJUST; return $s->ClassDateRel->new($s->[c_epoch]-$rhs->[c_epoch]+$dst_adjust); } elsif (blessed($rhs) && $rhs->isa("Class::Date::Rel")) { return $s->add(-$rhs); } elsif ($rhs) { return $s->add($s->ClassDateRel->new($rhs)->neg); } else { return $s; } } sub add { my ($s,$rhs)=@_; local $RANGE_CHECK; $rhs=$s->ClassDateRel->new($rhs) unless blessed($rhs) && $rhs->isa('Class::Date::Rel'); return $s unless blessed($rhs) && $rhs->isa('Class::Date::Rel'); # adding seconds my $retval= $rhs->[cs_sec] ? $s->new_from_scalar($s->[c_epoch]+$rhs->[cs_sec],$s->[c_tz]) : $s->new_copy($s); # adjust DST if necessary if ( $DST_ADJUST && (my $dstdiff=$retval->[c_isdst]-$s->[c_isdst])) { $retval->[c_epoch] -= $dstdiff*60*60; $retval->_recalc_from_epoch; } # adding months if ($rhs->[cs_mon]) { $retval->[c_mon]+=$rhs->[cs_mon]; my $year_diff= $retval->[c_mon]>0 ? # instead of POSIX::floor int ($retval->[c_mon]/12) : int (($retval->[c_mon]-11)/12); $retval->[c_mon] -= 12*$year_diff; my $expected_month = $retval->[c_mon]; $retval->[c_year] += $year_diff; $retval->_recalc_from_struct; # adjust month border if necessary if ($MONTH_BORDER_ADJUST && $retval && $expected_month != $retval->[c_mon]) { $retval->[c_epoch] -= $retval->[c_day]*60*60*24; $retval->_recalc_from_epoch; } } # sigh! We have finished! return $retval; } sub trunc { my ($s)=@_; return $s->new_from_array([$s->year,$s->month,$s->day,0,0,0],$s->[c_tz]); } *truncate = *trunc; sub get_epochs { my ($lhs,$rhs,$reverse)=@_; unless (blessed($rhs) && $rhs->isa( __PACKAGE__ )) { $rhs = $lhs->new($rhs); } my $repoch= $rhs ? $rhs->epoch : 0; return $repoch, $lhs->epoch if $reverse; return $lhs->epoch, $repoch; } sub compare { my ($lhs, $rhs) = get_epochs(@_); return $lhs <=> $rhs; } sub local_timezone { return (tzname_xs())[0]; } sub to_tz { my ($s, $tz) = @_; return $s->new($s->epoch, $tz); } 1; Class-Date-1.1.15/lib/Class/Date.pod000644 000765 000024 00000071464 12331115150 017154 0ustar00gaborstaff000000 000000 =encoding utf8 =head1 NAME Class::Date - Class for easy date and time manipulation =head1 SYNOPSIS use Class::Date qw(:errors date localdate gmdate now -DateParse -EnvC); # creating absolute date object (local time) $date = Class::Date->new( [$year,$month,$day,$hour,$min,$sec]); $date = date [$year,$month,$day,$hour,$min,$sec]; # ^- "date" is an exportable function, the same as Class::Date->new $date = date { year => $year, month => $month, day => $day, hour => $hour, min => $min, sec => $sec }; $date = date "2001-11-12 07:13:12"; $date = localdate "2001-12-11"; $date = now; # the same as date(time) $date = date($other_date_object); # cloning ... # creating absolute date object (GMT) $date = Class::Date->new( [$year,$month,$day,$hour,$min,$sec],'GMT'); $date = gmdate "2001-11-12 17:13"; ... # creating absolute date object in any other timezone $date = Class::Date->new( [$year,$month,$day,$hour,$min,$sec],'Iceland' ); $date = date "2001-11-12 17:13", 'Iceland'; $date2 = $date->new([$y2, $m2, $d2, $h2, $m2, $s2]); # ^- timezone is inherited from the $date object # creating relative date object # (normally you don't need to create this object explicitly) $reldate = Class::Date::Rel->new( "3Y 1M 3D 6h 2m 4s" ); $reldate = Class::Date::Rel->new( "6Y" ); $reldate = Class::Date::Rel->new( $secs ); # secs $reldate = Class::Date::Rel->new( [$year,$month,$day,$hour,$min,$sec] ); $reldate = Class::Date::Rel->new( { year => $year, month => $month, day => $day, hour => $hour, min => $min, sec => $sec } ); $reldate = Class::Date::Rel->new( "2001-11-12 07:13:12" ); $reldate = Class::Date::Rel->new( "2001-12-11" ); # getting values of an absolute date object $date; # prints the date in default output format (see below) $date->year; # year, e.g: 2001 $date->_year; # year - 1900, e.g. 101 $date->yr; # 2-digit year 0-99, e.g 1 $date->mon; # month 1..12 $date->month; # same as prev. $date->_mon; # month 0..11 $date->_month; # same as prev. $date->day; # day of month $date->mday; # day of month $date->day_of_month;# same as prev. $date->hour; $date->min; $date->minute; # same as prev. $date->sec; $date->second; # same as prev. $date->wday; # 1 = Sunday $date->_wday; # 0 = Sunday $date->day_of_week; # same as prev. $date->yday; $date->day_of_year; # same as prev. $date->isdst; # DST? $date->daylight_savings; # same as prev. $date->epoch; # UNIX time_t $date->monname; # name of month, eg: March $date->monthname; # same as prev. $date->wdayname; # Thursday $date->day_of_weekname # same as prev. $date->hms # 01:23:45 $date->ymd # 2000/02/29 $date->mdy # 02/29/2000 $date->dmy # 29/02/2000 $date->meridiam # 01:23 AM $date->ampm # AM/PM $date->string # 2000-02-29 12:21:11 (format can be changed, look below) "$date" # same as prev. $date->tzoffset # timezone-offset $date->strftime($format) # POSIX strftime (without the huge POSIX.pm) $date->tz # returns the base timezone as you specify, eg: CET $date->tzdst # returns the real timezone with dst information, eg: CEST ($year,$month,$day,$hour,$min,$sec)=$date->array; ($year,$month,$day,$hour,$min,$sec)=@{ $date->aref }; # !! $year: 1900-, $month: 1-12 ($sec,$min,$hour,$day,$mon,$year,$wday,$yday,$isdst)=$date->struct; ($sec,$min,$hour,$day,$mon,$year,$wday,$yday,$isdst)=@{ $date->sref }; # !! $year: 0-, $month: 0-11 $hash=$date->href; # $href can be reused as a constructor print $hash->{year}."-".$hash->{month}. ... $hash->{sec} ... ; %hash=$date->hash; # !! $hash{year}: 1900-, $hash{month}: 1-12 $date->month_begin # First day of the month (date object) $date->month_end # Last day of the month $date->days_in_month # 28..31 # constructing new date based on an existing one: $new_date = $date->clone; $new_date = $date->clone( year => 1977, sec => 14 ); # valid keys: year, _year, month, mon, _month, _mon, day, mday, day_of_month, # hour, min, minute, sec, second, tz # constructing a new date, which is the same as the original, but in # another timezone: $new_date = $date->to_tz('Iceland'); # changing date format { local $Class::Date::DATE_FORMAT="%Y%m%d%H%M%S"; print $date # result: 20011222000000 $Class::Date::DATE_FORMAT=undef; print $date # result: Thu Oct 13 04:54:34 1994 $Class::Date::DATE_FORMAT="%Y/%m/%d" print $date # result: 1994/10/13 } # error handling $a = date($date_string); if ($a) { # valid date ... } else { # invalid date if ($a->error == E_INVALID) { ... } print $a->errstr; } # adjusting DST in calculations (see the doc) $Class::Date::DST_ADJUST = 1; # this is the default $Class::Date::DST_ADJUST = 0; # "month-border adjust" flag $Class::Date::MONTH_BORDER_ADJUST = 0; # this is the default print date("2001-01-31")+'1M'; # will print 2001-03-03 $Class::Date::MONTH_BORDER_ADJUST = 1; print date("2001-01-31")+'1M'; # will print 2001-02-28 # date range check $Class::Date::RANGE_CHECK = 0; # this is the default print date("2001-02-31"); # will print 2001-03-03 $Class::Date::RANGE_CHECK = 1; print date("2001-02-31"); # will print nothing # getting values of a relative date object $reldate; # reldate in seconds (assumed 1 month = 2_629_744 secs) $reldate->year; $reldate->mon; $reldate->month; # same as prev. $reldate->day; $reldate->hour; $reldate->min; $reldate->minute; # same as prev. $reldate->sec; # same as $reldate $reldate->second; # same as prev. $reldate->sec_part; # "second" part of the relative date $reldate->mon_part; # "month" part of the relative date # arithmetic with dates: print date([2001,12,11,4,5,6])->truncate; # will print "2001-12-11" $new_date = $date+$reldate; $date2 = $date+'3Y 2D'; # 3 Years and 2 days $date3 = $date+[1,2,3]; # $date plus 1 year, 2 months, 3 days $date4 = $date+'3-1-5' # $date plus 3 years, 1 months, 5 days $new_date = $date-$reldate; $date2 = $date-'3Y'; # 3 Yearss $date3 = $date-[1,2,3]; # $date minus 1 year, 2 months, 3 days $date4 = $date-'3-1-5' # $date minus 3 years, 1 month, 5 days $new_reldate = $date1-$date2; $reldate2 = Class::Date->new('2000-11-12')-'2000-11-10'; $reldate3 = $date3-'1977-11-10'; $days_between = (Class::Date->new('2001-11-12')-'2001-07-04')->day; # comparison between absolute dates print $date1 > $date2 ? "I am older" : "I am younger"; # comparison between relative dates print $reldate1 > $reldate2 ? "I am faster" : "I am slower"; # Adding / Subtracting months and years are sometimes tricky: print date("2001-01-29") + '1M' - '1M'; # gives "2001-02-01" print date("2000-02-29") + '1Y' - '1Y'; # gives "2000-03-01" # Named interface ($date2 does not necessary to be a Class::Date object) $date1->string; # same as $date1 in scalar context $date1->subtract($date2); # same as $date1 - $date2 $date1->add($date2); # same as $date1 + $date2 $date1->compare($date2); # same as $date1 <=> $date2 $reldate1->sec; # same as $reldate1 in numeric or scalar context $reldate1->compare($reldate2);# same as $reldate1 <=> $reldate2 $reldate1->add($reldate2); # same as $reldate1 + $reldate2 $reldate1->neg # used for subtraction # Disabling Class::Date warnings at load time BEGIN { $Class::Date::WARNINGS=0; } use Class::Date; =head1 DESCRIPTION This module is intended to provide a general-purpose date and datetime type for perl. You have a Class::Date class for absolute date and datetime, and have a Class::Date::Rel class for relative dates. You can use "+", "-", "<" and ">" operators as with native perl data types. =head1 USAGE If you want to use a date object, you need to do the following: - create a new object - do some operations (+, -, comparison) - get result back =head2 Creating a new date object You can create a date object by the "date", "localdate" or "gmdate" function, or by calling the Class::Date constructor. "date" and "Class::Date->new" are equivalent, both has two arguments: The date and the timezone. $date1= date [2000,11,12]; $date2= Class::Date->new([2000,06,11,13,11,22],'GMT'); $date2= $date1->new([2000,06,11,13,11,22]); If the timezone information is omitted, then it first check if "new" is called as an object method or a class method. If it is an object method, then it inherits the timezone from the base object, otherwise the default timezone is used ($Class::Date::DEFAULT_TIMEZONE), which is usually set to the local timezone (which is stored in $Class::Date::LOCAL_TIMEZONE). These two variables are set only once to the value, which is returned by the Class::Date::local_timezone() function. You can change these values whenever you want. "localdate $x" is equivalent to "date $x, $Class::Date::LOCAL_TIMEZONE", "gmdate $x" is equivalent to "date $x, $Class::Date::GMT_TIMEZONE". $Class::Date::GMT_TIMEZONE is set to 'GMT' by default. $date1= localdate [2000,11,12]; $date2= gmdate [2000,4,2,3,33,33]; $date = localdate(time); The format of the accepted input date can be: =over 4 =item [$year,$month,$day,$hour,$min,$sec] An array reference with 6 elements. The missing elements have default values (year: 2000, month, day: 1, hour, min, sec: 0) =item { year => $year, month => $month, day => $day, hour => $hour, min => $min, sec => $sec } A hash reference with the same 6 elements as above. =item "YYYYMMDDhhmmss" A mysql-style timestamp value, which consist of at least 14 digit. =item "973897262" A valid 32-bit integer: This is parsed as a unix time. =item "YYYY-MM-DD hh:mm:ss" A standard ISO(-like) date format. Additional ".fraction" part is ignored, ":ss" can be omitted. =item additional input formats You can specify "-DateParse" as an import parameter, e.g: use Class::Date qw(date -DateParse); With this, the module will try to load Date::Parse module, and if it find it then all these formats can be used as an input. Please refer to the Date::Parse documentation. =back =head2 Operations =over 4 =item addition You can add the following to a Class::Date object: - a valid Class::Date::Rel object - anything, that can be used for creating a new Class::Date::Rel object It means that you don't need to create a new Class::Date::Rel object every time when you add something to the Class::Date object, it creates them automatically: $date= Class::Date->new('2001-12-11')+Class::Date::Rel->new('3Y'); is the same as: $date= date('2001-12-11')+'3Y'; You can provide a Class::Date::Rel object in the following form: =over 4 =item array ref The same format as seen in Class::Date format, except the default values are different: all zero. =item hash ref The same format as seen in Class::Date format, except the default values are different: all zero. =item "973897262" A valid 32-bit integer is parsed as seconds. =item "YYYY-MM-DD hh:mm:ss" A standard ISO date format, but this is parsed as relative date date and time, so month, day and year can be zero (and defaults to zero). =item "12Y 6M 6D 20h 12m 5s" This special string can be used if you don't want to use the ISO format. This string consists of whitespace separated tags, each tag consists of a number and a unit. The units can be: Y: year M: month D: day h: hour m: min s: sec The number and unit must be written with no space between them. =back =item substraction The same rules are true for substraction, except you can substract two Class::Date object from each other, and you will get a Class::Date::Rel object: $reldate=$date1-$date2; $reldate=date('2001-11-12 12:11:07')-date('2001-10-07 10:3:21'); In this case, the "month" field of the $reldate object will be 0, and the other fields will contain the difference between two dates; =item comparison You can compare two Class::Date objects, or one Class::Date object and another data, which can be used for creating a new Class::Data object. It means that you don't need to bless both objects, one of them can be a simple string, array ref, hash ref, etc (see how to create a date object). if ( date('2001-11-12') > date('2000-11-11') ) { ... } or if ( date('2001-11-12') > '2000-11-11' ) { ... } =item truncate You can chop the time value from this object (set hour, min and sec to 0) with the "truncate" or "trunc" method. It does not modify the specified object, it returns with a new one. =item clone You can create new date object based on an existing one, by using the "clone" method. Note, this DOES NOT modify the base object. $new_date = $date->clone( year => 2001, hour => 14 ); The valid keys are: year, _year, month, mon, _month, _mon, day, mday, day_of_month, hour, min, minute, sec, second, tz. There is a "set" method, which does the same as the "clone", it exists only for compatibility. =item to_tz You can use "to_tz" to create a new object, which means the same time as the base object, but in the different timezone. Note that $date->clone( tz => 'Iceland') and $date->to_tz('Iceland') is not the same! Cloning a new object with setting timezone will preserve the time information (hour, minute, second, etc.), but transfer the time into other timezone, while to_tz usually change these values based on the difference between the source and the destination timezone. =item Operations with Class::Date::Rel The Class::Date::Rel object consists of a month part and a day part. Most people only use the "day" part of it. If you use both part, then you can get these parts with the "sec_part" and "mon_part" method. If you use "sec", "month", etc. methods or if you use this object in a mathematical conent, then this object is converted to one number, which is interpreted as second. The conversion is based on a 30.436 days month. Don't use it too often, because it is confusing... If you use Class::Date::Rel in an expression with other Class::Date or Class::Date::Rel objects, then it does what is expected: date('2001-11-12')+'1M' will be '2001-12-12' and date('1996-02-11')+'2M' will be '1996-04-11' =back =head2 Accessing data from a Class::Date and Class::Date::Rel object You can use the methods methods described at the top of the document if you want to access parts of the data which is stored in a Class::Date and Class::Date::Rel object. =head2 Error handling If a date object became invalid, then the object will be reblessed to Class::Date::Invalid. This object is false in boolean environment, so you can test the date validity like this: $a = date($input_date); if ($a) { # valid date ... } else { # invalid date if ($a->error == E_INVALID) { ... } print $a->errstr; } Note even the date is invalid, the expression "defined $a" always returns true, so the following is wrong: $a = date($input_date); if (defined $a) ... # WRONG!!!! You can test the error by getting the $date->error value. You might import the ":errors" tag: use Class::Date qw(:errors); Possible error values are: =over 4 =item E_OK No errors. =item E_INVALID Invalid date. It is set when some of the parts of the date are invalid, and Time::Local functions cannot convert them to a valid date. =item E_RANGE This error is set, when parts of the date are valid, but the whole date is not valid, e.g. 2001-02-31. When the $Class::Date::RANGE_CHECK is not set, then these date values are automatically converted to a valid date: 2001-03-03, but the $date->error value are set to E_RANGE. If $Class::Date::RANGE_CHECK is set, then a date "2001-02-31" became invalid date. =item E_UNPARSABLE This error is set, when the constructor cannot be created from a scalar, e.g: $a = date("4kd sdlsdf lwekrmk"); =item E_UNDEFINED This error is set, when you want to create a date object from an undefined value: $a = Class::Date->new(undef); Note, that localdate(undef) will create a valid object, because it calls $Class::Date(time). =back You can get the error in string form by calling the "errstr" method. =head1 DST_ADJUST $DST_ADJUST is an important configuration option. If it is set to true (default), then the module adjusts the date and time when the operation switches the border of DST. With this setting, you are ignoring the effect of DST. When $DST_ADJUST is set to false, then no adjustment is done, the calculation will be based on the exact time difference. You will see the difference through an example: $Class::Date::DST_ADJUST=1; print date("2000-10-29", "CET") + "1D"; # This will print 2000-10-30 00:00:00 print date("2001-03-24 23:00:00", "CET") + "1D"; # This will be 2001-03-25 23:00:00 print date("2001-03-25", "CET") + "1D"; # This will be 2001-03-26 00:00:00 $Class::Date::DST_ADJUST=0; print date("2000-10-29", "CET") + "1D"; # This will print 2000-10-29 23:00:00 print date("2001-03-24 23:00:00", "CET") + "1D"; # This will be 2001-03-26 00:00:00 =head1 MONTHS AND YEARS If you add or subtract "months" and "years" to a date, you may get wrong dates, e.g when you add one month to 2001-01-31, you expect to get 2001-02-31, but this date is invalid and converted to 2001-03-03. Thats' why date("2001-01-31") + '1M' - '1M' != "2001-01-31" This problem can occur only with months and years, because others can easily be converted to seconds. =head1 MONTH_BORDER_ADJUST $MONTH_BORDER_ADJUST variable is used to switch on or off the month-adjust feature. This is used only when someone adds months or years to a date and then the resulted date became invalid. An example: adding one month to "2001-01-31" will result "2001-02-31", and this is an invalid date. When $MONTH_BORDER_ADJUST is false, this result simply normalized, and becomes "2001-03-03". This is the default behaviour. When $MONTH_BORDER_ADJUST is true, this result becomes "2001-02-28". So when the date overflows, then it returns the last day insted. Both settings keep the time information. =head1 WORKING WITHOUT A C COMPILER Class::Date can be used without a C compiler since 1.0.8. If you want to do this, you only need to copy the "Date.pm" whereever your perl compiler searches for it. You must make a "Class" directory for it before. In Debian GNU/Linux system (woody) , a good choice can be the following: mkdir /usr/local/share/perl/5.6.1/Class cp Date.pm /usr/local/share/perl/5.6.1/Class And the module will work. You can use the $WARNINGS switch to switch off the complains about the missing XS part from your perl program: BEGIN { $Class::Date::WARNINGS=0; } use Class::Date; ... =head1 TIMEZONE SUPPORT Since 1.0.11, Class::Date handle timezones natively on most platforms (see the BUGS AND LIMITATIONS section for more info). When the module is loaded, then it determines the local base timezone by calling the Class::Date::local_timezone() function, and stores these values into two variables, these are: $Class::Date::LOCAL_TIMEZONE and $Class::Date::DEFAULT_TIMEZONE. The first value is used, when you call the "localdate" function, the second value is used, when you call the "date" function and you don't specify the timezone. There is a $Class::Date::GMT_TIMEZONE function also, which is used by the "gmdate" function, this is set to 'GMT'. You can query the timezone of a date object by calling the $date->tz method. Note this value returns the timezone as you specify, so if you create the object with an unknown timezone, you will get this back. If you want to query the effective timezone, you can call the $date->tzdst method. This method returns only valid timezones, but it is not necessarily the timezone, which can be used to create a new object. For example $date->tzdst can return 'CEST', which is not a valid base timezone, because it contains daylight savings information also. On Linux systems, you can see the possible base timezones in the /usr/share/zoneinfo directory. In Class::Date 1.1.6, a new environment variable is introduced: $Class::Date::NOTZ_TIMEZONE. This variable stores the local timezone, which is used, when the TZ environment variable is not set. It is introduced, because there are some systems, which cannot handle the queried timezone well. For example the local timezone is CST, it is returned by the tzname() perl function, but when I set the TZ environment variable to CST, it works like it would be GMT. The workaround is NOTZ_TIMEZONE: if a date object has a timezone, which is the same as NOTZ_TIMEZONE, then the TZ variable will be removed before each calculation. In normal case, it would be the same as setting TZ to $NOTZ_TIMEZONE, but some systems don't like it, so I decided to introduce this variable. The $Class::Date::NOTZ_TIMEZONE variable is set in the initialization of the module by removing the TZ variable from the environment and querying the tzname variable. =head1 INTERNALS This module uses operator overloading very heavily. I've found it quite stable, but I am afraid of it a bit. A Class::Date object is an array reference. A Class::Date::Rel object is an array reference, which contains month and second information. I need to store it as an array ref, because array and month values cannot be converted into seconds, because of our super calendar. You can add code references to the @Class::Date::NEW_FROM_SCALAR and @Class::Date::Rel::NEW_FROM_SCALAR. These arrays are iterated through when a scalar-format date must be parsed. These arrays only have one or two values at initialization. The parameters which the code references got are the same as the "new" method of each class. In this way, you can personalize the date parses as you want. As of 0.90, the Class::Date has been rewritten. A lot of code and design decision has been borrowed from Matt Sergeant's Time::Object, and there will be some incompatibility with the previous public version (0.5). I tried to keep compatibility methods in Class::Date. If you have problems regarding this, please drop me an email with the description of the problem, and I will set the compatibility back. Invalid dates are Class::Date::Invalid objects. Every method call on this object and every operation with this object returns undef or 0. =head1 DEVELOPMENT FOCUS This module tries to be as full-featured as can be. It currently lacks business-day calculation, which is planned to be implemented in the 1.0.x series. I try to keep this module not to depend on other modules and I want this module usable without a C compiler. Currently the module uses the POSIX localtime function very extensively. This makes the date calculation a bit slow, but provides a rich interface, which is not provided by any other module. When I tried to redesign the internals to not depend on localtime, I failed, because there are no other way to determine the daylight savings information. =head1 SPEED ISSUES There are two kind of adjustment in this module, DST_ADJUST and MONTH_BORDER_ADJUST. Both of them makes the "+" and "-" operations slower. If you don't need them, switch them off to achieve faster calculations. In general, if you really need fast date and datetime calculation, don't use this module. As you see in the previous section, the focus of development is not the speed in 1.0. For fast date and datetime calculations, use Date::Calc module instead. =head1 THREAD SAFETY and MOD_PERL This module is NOT thread-safe, since it uses C library functions, which are not thread-safe. Using this module in a multi-threaded environment can cause timezones to be messed up. I did not put any warning about it, you have to make sure that you understand this! Under some circumstances in a mod_perl environment, you require the Env::C module to set the TZ variable properly before calling the time functions. I added the -EnvC import option to automatically load this module if it is not loaded already. Please read the mod_perl documentation about the environment variables and mod_perl to get the idea why it is required sometimes: http://perl.apache.org/docs/2.0/user/troubleshooting/troubleshooting.html#C_Libraries_Don_t_See_C__ENV__Entries_Set_by_Perl_Code You are sure have this problem if the $Class::Date::NOTZ_TIMEZONE variable is set to 'UTC', althought you are sure that your timezone is not that. Try -EnvC in this case, but make sure that you are not using it in a multi-threaded environment! =head1 OTHER BUGS AND LIMITATIONS =over 4 =item * Not all date/time values can be expressed in all timezones. For example: print date("2010-10-03 02:00:00", "Australia/Sydney") # it will print 2010-10-03 03:00:00 No matter how hard you try you, you are not going to be able to express the time in the example in that timezone. If you don't need the timezone information and you want to make sure that the calculations are always correct, please use GMT as a timezone (the 'gmdate' function can be a shortcut for it). In this case, you might also consider turning off DST_ADJUST to speed up the calculation. =item * I cannot manage to get the timezone code working properly on ActivePerl 5.8.0 on win XP and earlier versions possibly have this problem also. If you have a system like this, then you will have only two timezones, the local and the GMT. Every timezone, which is not equal to $Class::Date::GMT_TIMEZONE is assumed to be local. This seems to be caused by the win32 implementation of timezone routines. I don't really know how to make this thing working, so I gave up this issue. If anyone know a working solution, then I will integrate it into Class::Date, but until then, the timezone support will not be available for these platforms. =item * Perl 5.8.0 and earlier versions has a bug in the strftime code on some operating systems (for example Linux), which is timezone related. I recommend using the strftime, which is provided with Class::Date, so don't try to use the module without the compiled part. The module will not work with a buggy strftime - the test is hardcoded into the beginning of the code. If you anyway want to use the module, remove the hardcoded "die" from the module, but do it for your own risk. =item * This module uses the POSIX functions for date and time calculations, so it is not working for dates beyond 2038 and before 1902. I don't know what systems support dates in 1902-1970 range, it may not work on your system. I know it works on the Linux glibc system with perl 5.6.1 and 5.7.2. I know it does not work with perl 5.005_03 (it may be the bug of the Time::Local module). Please report if you know any system where it does _not_ work with perl 5.6.1 or later. I hope that someone will fix this with new time_t in libc. If you really need dates over 2038 and before 1902, you need to completely rewrite this module or use Date::Calc or other date modules. =item * This module uses Time::Local, and when it croaks, Class::Date returns "Invalid date or time" error message. Time::Local is different in the 5.005 and 5.6.x (and even 5.7.x) version of perl, so the following code will return different results: $a = date("2006-11-11")->clone(year => -1); In perl 5.6.1, it returns an invalid date with error message "Invali date or time", in perl 5.005 it returns an invalid date with range check error. Both are false if you use them in boolean context though, only the error message is different, but don't rely on the error message in this case. It however works in the same way if you change other fields than "year" to an invalid field. =back =head1 SUPPORT Class::Date is free software. IT COMES WITHOUT WARRANTY OF ANY KIND. If you have questions, you can send questions directly to me: dlux@dlux.hu =head1 WIN32 notes You can get a binary win32 version of Class::Date from Chris Winters' .ppd repository with the following commands: For people using PPM2: c:\> ppm PPM> set repository oi http://openinteract.sourceforge.net/ppmpackages/ PPM> set save PPM> install Class-Date For people using PPM3: c:\> ppm PPM> repository http://openinteract.sourceforge.net/ppmpackages/ PPM> install Class-Date The first steps in PPM only needs to be done at the first time. Next time you just run the 'install'. =head1 COPYRIGHT Copyright (c) 2001 Szabó, Balázs (dLux) All rights reserved. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. Portions Copyright (c) Matt Sergeant =head1 AUTHOR dLux (Szabó, Balázs) =head1 MAINTAINER L =head1 CREDITS - Matt Sergeant (Lots of code are borrowed from the Time::Object module) - Tatsuhiko Miyagawa (bugfixes) - Stas Bekman (suggestions, bugfix) - Chris Winters (win32 .ppd version) - Benoit Beausejour (Parts of the timezone code is borrowed from his Date::Handler module) =head1 SEE ALSO perl(1). Date::Calc(3pm). Time::Object(3pm). Date::Handler(3pm). =cut Class-Date-1.1.15/lib/Class/Date/Const.pm000644 000765 000024 00000002431 12331601116 020062 0ustar00gaborstaff000000 000000 package Class::Date::Const; use strict; use vars qw(@EXPORT @ISA @ERROR_MESSAGES %EXPORT_TAGS); use Exporter; our $VERSION = '1.1.15'; my %FIELDS = ( # Class::Date fields c_year => 0, c_mon => 1, c_day => 2, c_hour => 3, c_min => 4, c_sec => 5, c_wday => 6, c_yday => 7, c_isdst => 8, c_epoch => 9, c_tz => 10, c_error => 11, c_errmsg => 12, # Class::Date::Rel fields cs_mon => 0, cs_sec => 1, # Class::Date::Invalid fields ci_error => 0, ci_errmsg => 1, ); eval " sub $_ () { ".$FIELDS{$_}."}" foreach keys %FIELDS; @ISA = qw(Exporter); my @ERRORS = ( E_OK => '', E_INVALID => 'Invalid date or time', E_RANGE => 'Range check on date or time failed', E_UNPARSABLE => 'Unparsable date or time: %s', E_UNDEFINED => 'Undefined date object', ); my @ERR; # predeclaring error constants my $c = 0; while (@ERRORS) { my $errorcode = shift @ERRORS; my $errorname = shift @ERRORS; eval "sub $errorcode () { $c }"; $ERROR_MESSAGES[$c] = $errorname; push @{$EXPORT_TAGS{errors}}, $errorcode; $c++; } @EXPORT = (keys %FIELDS, qw(@ERROR_MESSAGES), @{$EXPORT_TAGS{errors}}); 1; Class-Date-1.1.15/lib/Class/Date/Invalid.pm000644 000765 000024 00000001106 12331601134 020360 0ustar00gaborstaff000000 000000 package Class::Date::Invalid; use strict; use warnings; use Class::Date::Const; our $VERSION = '1.1.15'; use overload '0+' => "zero", '""' => "empty", '<=>' => "compare", 'cmp' => "compare", '+' => "zero", '!' => "true", fallback => 1; sub empty { "" } sub zero { 0 } sub true { 1 } sub compare { return ($_[1] ? 1 : 0) * ($_[2] ? -1 : 1) } sub error { shift->[ci_error]; } sub errmsg { my ($s) = @_; sprintf $ERROR_MESSAGES[ $s->[ci_error] ]."\n", $s->[ci_errmsg] } *errstr = *errmsg; sub AUTOLOAD { undef } 1; Class-Date-1.1.15/lib/Class/Date/Rel.pm000644 000765 000024 00000007163 12331601162 017526 0ustar00gaborstaff000000 000000 package Class::Date::Rel; use strict; use warnings; use vars qw(@NEW_FROM_SCALAR); use Class::Date::Const; use Scalar::Util qw(blessed); our $VERSION = '1.1.15'; use constant SEC_PER_MONTH => 2_629_744; # see the ClassDateRel const in package Class::Date use constant ClassDate => "Class::Date"; use overload '0+' => "sec", '""' => "sec", '<=>' => "compare", 'cmp' => "compare", '+' => "add", 'neg' => "neg", fallback => 1; sub new { my ($proto,$val)=@_; my $class = ref($proto) || $proto; return undef if !defined $val; if (blessed($val) && $val->isa( __PACKAGE__ )) { return $class->new_copy($val); } elsif (ref($val) eq 'ARRAY') { return $class->new_from_array($val); } elsif (ref($val) eq 'HASH') { return $class->new_from_hash($val); } elsif (ref($val) eq 'SCALAR') { return $class->new_from_scalar($$val); } else { return $class->new_from_scalar($val); }; } sub new_copy { my ($s,$val)=@_; return bless([@$val], ref($s)||$s); } sub new_from_array { my ($s,$val) = @_; my ($y,$m,$d,$hh,$mm,$ss) = @$val; return bless([ ($y || 0) * 12 + $m , ($ss || 0) + 60*(($mm || 0) + 60*(($hh || 0) + 24* ($d || 0))) ], ref($s)||$s); } sub new_from_hash { my ($s,$val) = @_; $s->new_from_array(Class::Date::_array_from_hash($val)); } sub new_from_scalar { my ($s,$val)=@_; for (my $i=0;$i<@NEW_FROM_SCALAR;$i++) { my $ret=$NEW_FROM_SCALAR[$i]->($s,$val); return $ret if defined $ret; } return undef; } sub new_from_scalar_internal { my ($s,$val)=@_; return undef if !defined $val; return bless([0,$1],ref($s) || $s) if $val =~ / ^ \s* ( \-? \d+ ( \. \d* )? ) \s* $/x; if ($val =~ m{ ^\s* ( \d{1,4} ) - ( \d\d? ) - ( \d\d? ) ( \s+ ( \d\d? ) : ( \d\d? ) ( : ( \d\d? )? (\.\d+)? )? )? }x ) { # ISO date my ($y,$m,$d,$hh,$mm,$ss)=($1,$2,$3,$5,$6,$8); return $s->new_from_array([$y,$m,$d,$hh,$mm,$ss]); } my ($y,$m,$d,$hh,$mm,$ss)=(0,0,0,0,0,0); $val =~ s{ \G \s* ( \-? \d+) \s* (Y|M|D|h|m|s) }{ my ($num,$cmd)=($1,$2); if ($cmd eq 'Y') { $y=$num; } elsif ($cmd eq 'M') { $m=$num; } elsif ($cmd eq 'D') { $d=$num; } elsif ($cmd eq 'h') { $hh=$num; } elsif ($cmd eq 'm') { $mm=$num; } elsif ($cmd eq 's') { $ss=$num; } ""; }gexi; return $s->new_from_array([$y,$m,$d,$hh,$mm,$ss]); } push @NEW_FROM_SCALAR,\&new_from_scalar_internal; sub compare { my ($s,$val2,$reverse) = @_; my $rev_multiply=$reverse ? -1 : 1; if (blessed($val2) && $val2->isa( __PACKAGE__ )) { return ($s->sec <=> $val2->sec) * $rev_multiply; } else { my $date_obj=$s->new($val2); return ($s->sec <=> 0) * $rev_multiply if !defined $date_obj; return ($s->sec <=> $date_obj->sec) * $rev_multiply; } } sub add { my ($s,$val2)=@_; if (my $reldate=$s->new($val2)) { my $months=$s->[cs_mon] + $reldate->[cs_mon]; my $secs =$s->[cs_sec] + $reldate->[cs_sec]; return $s->new_from_hash({ month => $months, sec => $secs }) if $months; return $secs; } else { return $s; } } sub neg { my ($s)=@_; return $s->new_from_hash({ month => -$s->[cs_mon], sec => -$s->[cs_sec] }); } sub year { shift->sec / (SEC_PER_MONTH*12) } sub mon { shift->sec / SEC_PER_MONTH } *month = *mon; sub day { shift->sec / (60*60*24) } sub hour { shift->sec / (60*60) } sub min { shift->sec / 60 } *minute = *min; sub sec { my ($s)=@_; $s->[cs_sec] + SEC_PER_MONTH * $s->[cs_mon]; } *second = *sec; sub sec_part { shift->[cs_sec] } *second_part = *sec_part; sub mon_part { shift->[cs_mon] } *month_part = *mon_part; 1;