# [PATCH 1/2] Add date formatting and parsing functions relative to a given time 4 messages from 2009-08-28 to 2009-08-30. Participants: Alex Riesen, Jeff King. Thread: https://gitlist.dev/t/20778 ## Alex Riesen, 2009-08-28 21:04 Subject: [PATCH 1/2] Add date formatting and parsing functions relative to a given time Message-ID: <20090828210404.GA11867@blimp.localdomain> URL: https://gitlist.dev/e/20090828210404.GA11867%40blimp.localdomain ``` The main purpose is to allow predictable testing of the code. --- Rebased on current master. cache.h | 2 + date.c | 150 ++++++++++++++++++++++++++++++++++++-------------------------- 2 files changed, 89 insertions(+), 63 deletions(-) diff --git a/cache.h b/cache.h index dd7f71e..3fb0166 100644 --- a/cache.h +++ b/cache.h @@ -731,9 +731,11 @@ enum date_mode { }; const char *show_date(unsigned long time, int timezone, enum date_mode mode); +const char *show_date_relative(unsigned long time, int tz, const struct timeval *now); int parse_date(const char *date, char *buf, int bufsize); void datestamp(char *buf, int bufsize); unsigned long approxidate(const char *); +unsigned long approxidate_relative(const char *date, const struct timeval *now); enum date_mode parse_date_format(const char *format); #define IDENT_WARN_ON_NO_NAME 1 diff --git a/date.c b/date.c index f011692..0840e77 100644 --- a/date.c +++ b/date.c @@ -84,6 +84,67 @@ static int local_tzoffset(unsigned long time) return offset * eastwest; } +const char *show_date_relative(unsigned long time, int tz, const struct timeval *now) +{ + static char timebuf[100 /* TODO: can be optimized */]; + unsigned long diff; + if (now->tv_sec < time) + return "in the future"; + diff = now->tv_sec - time; + if (diff < 90) { + snprintf(timebuf, sizeof(timebuf), "%lu seconds ago", diff); + return timebuf; + } + /* Turn it into minutes */ + diff = (diff + 30) / 60; + if (diff < 90) { + snprintf(timebuf, sizeof(timebuf), "%lu minutes ago", diff); + return timebuf; + } + /* Turn it into hours */ + diff = (diff + 30) / 60; + if (diff < 36) { + snprintf(timebuf, sizeof(timebuf), "%lu hours ago", diff); + return timebuf; + } + /* We deal with number of days from here on */ + diff = (diff + 12) / 24; + if (diff < 14) { + snprintf(timebuf, sizeof(timebuf), "%lu days ago", diff); + return timebuf; + } + /* Say weeks for the past 10 weeks or so */ + if (diff < 70) { + snprintf(timebuf, sizeof(timebuf), "%lu weeks ago", (diff + 3) / 7); + return timebuf; + } + /* Say months for the past 12 months or so */ + if (diff < 360) { + snprintf(timebuf, sizeof(timebuf), "%lu months ago", (diff + 15) / 30); + return timebuf; + } + /* Give years and months for 5 years or so */ + if (diff < 1825) { + unsigned long years = diff / 365; + unsigned long months = (diff % 365 + 15) / 30; + int n; + n = snprintf(timebuf, sizeof(timebuf), "%lu year%s", + years, (years > 1 ? "s" : "")); + if (months) + snprintf(timebuf + n, sizeof(timebuf) - n, + ", %lu month%s ago", + months, (months > 1 ? "s" : "")); + else + snprintf(timebuf + n, sizeof(timebuf) - n, + " ago"); + return timebuf; + } + /* Otherwise, just years. Centuries is probably overkill. */ + snprintf(timebuf, sizeof(timebuf), "%lu years ago", (diff + 183) / 365); + return timebuf; + +} + const char *show_date(unsigned long time, int tz, enum date_mode mode) { struct tm *tm; @@ -95,63 +156,9 @@ const char *show_date(unsigned long time, int tz, enum date_mode mode) } if (mode == DATE_RELATIVE) { - unsigned long diff; struct timeval now; gettimeofday(&now, NULL); - if (now.tv_sec < time) - return "in the future"; - diff = now.tv_sec - time; - if (diff < 90) { - snprintf(timebuf, sizeof(timebuf), "%lu seconds ago", diff); - return timebuf; - } - /* Turn it into minutes */ - diff = (diff + 30) / 60; - if (diff < 90) { - snprintf(timebuf, sizeof(timebuf), "%lu minutes ago", diff); - return timebuf; - } - /* Turn it into hours */ - diff = (diff + 30) / 60; - if (diff < 36) { - snprintf(timebuf, sizeof(timebuf), "%lu hours ago", diff); - return timebuf; - } - /* We deal with number of days from here on */ - diff = (diff + 12) / 24; - if (diff < 14) { - snprintf(timebuf, sizeof(timebuf), "%lu days ago", diff); - return timebuf; - } - /* Say weeks for the past 10 weeks or so */ - if (diff < 70) { - snprintf(timebuf, sizeof(timebuf), "%lu weeks ago", (diff + 3) / 7); - return timebuf; - } - /* Say months for the past 12 months or so */ - if (diff < 360) { - snprintf(timebuf, sizeof(timebuf), "%lu months ago", (diff + 15) / 30); - return timebuf; - } - /* Give years and months for 5 years or so */ - if (diff < 1825) { - unsigned long years = diff / 365; - unsigned long months = (diff % 365 + 15) / 30; - int n; - n = snprintf(timebuf, sizeof(timebuf), "%lu year%s", - years, (years > 1 ? "s" : "")); - if (months) - snprintf(timebuf + n, sizeof(timebuf) - n, - ", %lu month%s ago", - months, (months > 1 ? "s" : "")); - else - snprintf(timebuf + n, sizeof(timebuf) - n, - " ago"); - return timebuf; - } - /* Otherwise, just years. Centuries is probably overkill. */ - snprintf(timebuf, sizeof(timebuf), "%lu years ago", (diff + 183) / 365); - return timebuf; + return show_date_relative(time, tz, &now); } if (mode == DATE_LOCAL) @@ -866,19 +873,13 @@ static const char *approxidate_digit(const char *date, struct tm *tm, int *num) return end; } -unsigned long approxidate(const char *date) +static unsigned long approximation(const char *date, const struct timeval *tv) { int number = 0; struct tm tm, now; - struct timeval tv; time_t time_sec; - char buffer[50]; - if (parse_date(date, buffer, sizeof(buffer)) > 0) - return strtoul(buffer, NULL, 10); - - gettimeofday(&tv, NULL); - time_sec = tv.tv_sec; + time_sec = tv->tv_sec; localtime_r(&time_sec, &tm); now = tm; for (;;) { @@ -899,3 +900,26 @@ unsigned long approxidate(const char *date) tm.tm_year--; return mktime(&tm); } + +unsigned long approxidate_relative(const char *date, const struct timeval *tv) +{ + char buffer[50]; + + if (parse_date(date, buffer, sizeof(buffer)) > 0) + return strtoul(buffer, NULL, 10); + + return approximation(date, tv); +} + +unsigned long approxidate(const char *date) +{ + struct timeval tv; + char buffer[50]; + + if (parse_date(date, buffer, sizeof(buffer)) > 0) + return strtoul(buffer, NULL, 10); + + gettimeofday(&tv, NULL); + return approximation(date, &tv); +} + -- 1.6.4.1.263.g468a ``` ## Alex Riesen, 2009-08-28 21:05 Subject: [PATCH 2/2] Allow testing of _relative family of time formatting and parsing functions Message-ID: <20090828210511.GB11867@blimp.localdomain> URL: https://gitlist.dev/e/20090828210511.GB11867%40blimp.localdomain In-Reply-To: <20090828210404.GA11867@blimp.localdomain> ``` To complement the testability of approxidate. --- test-date.c | 17 +++++++++++++++++ 1 files changed, 17 insertions(+), 0 deletions(-) diff --git a/test-date.c b/test-date.c index 62e8f23..dcc7973 100644 --- a/test-date.c +++ b/test-date.c @@ -4,6 +4,17 @@ int main(int argc, char **argv) { int i; + struct tm tm; + struct timeval when = {0, 0}; + tm.tm_sec = 0; + tm.tm_min = 0; + tm.tm_hour = 12; + tm.tm_mday = 1; + tm.tm_mon = 0 /* January */; + tm.tm_year = 90 /* 1990 */ ; + tm.tm_isdst = -1; + when.tv_sec = mktime(&tm); + for (i = 1; i < argc; i++) { char result[100]; time_t t; @@ -15,6 +26,12 @@ int main(int argc, char **argv) t = approxidate(argv[i]); printf("%s -> %s\n", argv[i], ctime(&t)); + + t = approxidate_relative(argv[i], &when); + printf("relative: %s -> %s\n", argv[i], ctime(&t)); + + printf("relative: %s, out of %s\n", + show_date_relative(t, 0, &when), ctime(&t)); } return 0; } -- 1.6.4.1.263.g468a ``` ## Jeff King, 2009-08-30 07:36 Subject: Re: [PATCH 1/2] Add date formatting and parsing functions relative to a given time Message-ID: <20090830073619.GA14217@coredump.intra.peff.net> URL: https://gitlist.dev/e/20090830073619.GA14217%40coredump.intra.peff.net In-Reply-To: <20090828210404.GA11867@blimp.localdomain> ``` On Fri, Aug 28, 2009 at 11:04:04PM +0200, Alex Riesen wrote: > +const char *show_date_relative(unsigned long time, int tz, const struct timeval *now) > +{ > + static char timebuf[100 /* TODO: can be optimized */]; This was 200 in the original version. I doubt that it makes a difference, but I think in a refactoring patch I think it is best to simply reorganize and make no other changes. > +static unsigned long approximation(const char *date, const struct timeval *tv) I know it's static, but this is a terribly undescriptive function name. Approximation of what? Can we call it approxidate_internal or something? -Peff ``` ## Alex Riesen, 2009-08-30 07:51 Subject: Re: [PATCH 1/2] Add date formatting and parsing functions relative to a given time Message-ID: <81b0412b0908300051g19bc2c5buecf5d925bd0d40b6@mail.gmail.com> URL: https://gitlist.dev/e/81b0412b0908300051g19bc2c5buecf5d925bd0d40b6%40mail.gmail.com In-Reply-To: <20090830073619.GA14217@coredump.intra.peff.net> ``` On Sun, Aug 30, 2009 at 09:36, Jeff King wrote: > On Fri, Aug 28, 2009 at 11:04:04PM +0200, Alex Riesen wrote: > >> +const char *show_date_relative(unsigned long time, int tz, const struct timeval *now) >> +{ >> +     static char timebuf[100 /* TODO: can be optimized */]; > > This was 200 in the original version. I doubt that it makes a > difference, but I think in a refactoring patch I think it is best to > simply reorganize and make no other changes. Yes, I just noticed that 200 was much too much, made the note to fix it sometime and forgot the note in the final submission. >> +static unsigned long approximation(const char *date, const struct timeval *tv) > > I know it's static, but this is a terribly undescriptive function name. > Approximation of what?  Can we call it approxidate_internal or > something? Been there, tried that. Didn't like it, because it didn't feel enough approxidate (the original) anymore. Not even internally, because of missing parse_date. My other attempts were guessdate and approxidate_bottom_half (but only very shortly). The "approximation", if you consider the functions arguments, seems to me the closest to what the function _is_. OTOH, maybe I should have used a verb... ```