Ticket #7201: 7201.2.diff

File 7201.2.diff, 7.3 KB (added by Jeremy Carbaugh, 12 years ago)

Modification of original patch to not assume timezone when none exists.

  • django/utils/timesince.py

     
    2727    )
    2828    # Convert datetime.date to datetime.datetime for comparison
    2929    if d.__class__ is not datetime.datetime:
    30         d = datetime.datetime(d.year, d.month, d.day)
    31     if now:
    32         t = now.timetuple()
    33     else:
    34         t = time.localtime()
    35     if d.tzinfo:
    36         tz = LocalTimezone(d)
    37     else:
    38         tz = None
    39     now = datetime.datetime(t[0], t[1], t[2], t[3], t[4], t[5], tzinfo=tz)
     30        d = datetime.datetime(d.year, d.month, d.day)   
    4031
     32    if not now:
     33        if d.tzinfo:
     34            now = datetime.datetime.now(LocalTimezone(d))
     35        else:
     36            now = datetime.datetime.now()
     37
    4138    # ignore microsecond part of 'd' since we removed it from 'now'
    4239    delta = now - (d - datetime.timedelta(0, 0, d.microsecond))
    4340    since = delta.days * 24 * 60 * 60 + delta.seconds
     
    6259    Like timesince, but returns a string measuring the time until
    6360    the given time.
    6461    """
    65     if now == None:
    66         now = datetime.datetime.now()
     62    if not now:
     63        if d.tzinfo:
     64            now = datetime.datetime.now(LocalTimezone(d))
     65        else:
     66            now = datetime.datetime.now()
    6767    return timesince(now, d)
  • django/template/defaultfilters.py

     
    642642    from django.utils.timesince import timesince
    643643    if not value:
    644644        return u''
    645     if arg:
    646         return timesince(arg, value)
    647     return timesince(value)
     645    try:
     646        if arg:
     647            return timesince(arg, value)
     648        return timesince(value)
     649    except (ValueError, TypeError):
     650        return u''
    648651timesince.is_safe = False
    649652
    650653def timeuntil(value, arg=None):
    651654    """Formats a date as the time until that date (i.e. "4 days, 6 hours")."""
    652     from django.utils.timesince import timesince
     655    from django.utils.timesince import timeuntil
    653656    from datetime import datetime
    654657    if not value:
    655658        return u''
    656     if arg:
    657         return timesince(arg, value)
    658     return timesince(datetime.now(), value)
     659    try:
     660        return timeuntil(value, arg)
     661    except (ValueError, TypeError):
     662        return u''
    659663timeuntil.is_safe = False
    660664
    661665###################
  • tests/regressiontests/templates/filters.py

     
    99
    1010from datetime import datetime, timedelta
    1111
    12 from django.utils.tzinfo import LocalTimezone
     12from django.utils.tzinfo import LocalTimezone, FixedOffset
    1313from django.utils.safestring import mark_safe
    1414
    1515# These two classes are used to test auto-escaping of __unicode__ output.
     
    2020class SafeClass:
    2121    def __unicode__(self):
    2222        return mark_safe(u'you > me')
    23 
     23       
    2424# RESULT SYNTAX --
    2525# 'template_name': ('template contents', 'context dict',
    2626#                   'expected string output' or Exception class)
    2727def get_filter_tests():
    2828    now = datetime.now()
    2929    now_tz = datetime.now(LocalTimezone(now))
     30    now_tz_i = datetime.now(FixedOffset((3 * 60) + 15)) # imaginary time zone
    3031    return {
    3132        # Default compare with datetime.now()
    3233        'filter-timesince01' : ('{{ a|timesince }}', {'a': datetime.now() + timedelta(minutes=-1, seconds = -10)}, '1 minute'),
     
    4041        # Check that timezone is respected
    4142        'filter-timesince06' : ('{{ a|timesince:b }}', {'a':now_tz + timedelta(hours=8), 'b':now_tz}, '8 hours'),
    4243
     44        # Ensures that differing timezones are calculated correctly
     45        'filter-timesince07' : ('{{ a|timesince }}', {'a': now}, '0 minutes'),
     46        'filter-timesince08' : ('{{ a|timesince }}', {'a': now_tz}, '0 minutes'),
     47        'filter-timesince09' : ('{{ a|timesince }}', {'a': now_tz_i}, '0 minutes'),
     48        'filter-timesince10' : ('{{ a|timesince:b }}', {'a': now_tz, 'b': now_tz_i}, '0 minutes'),
     49        'filter-timesince11' : ('{{ a|timesince:b }}', {'a': now, 'b': now_tz_i}, ''),
     50        'filter-timesince12' : ('{{ a|timesince:b }}', {'a': now_tz_i, 'b': now}, ''),
     51       
    4352        # Default compare with datetime.now()
    4453        'filter-timeuntil01' : ('{{ a|timeuntil }}', {'a':datetime.now() + timedelta(minutes=2, seconds = 10)}, '2 minutes'),
    4554        'filter-timeuntil02' : ('{{ a|timeuntil }}', {'a':(datetime.now() + timedelta(days=1, seconds = 10))}, '1 day'),
     
    4958        'filter-timeuntil04' : ('{{ a|timeuntil:b }}', {'a':now - timedelta(days=1), 'b':now - timedelta(days=2)}, '1 day'),
    5059        'filter-timeuntil05' : ('{{ a|timeuntil:b }}', {'a':now - timedelta(days=2), 'b':now - timedelta(days=2, minutes=1)}, '1 minute'),
    5160
     61        # Ensures that differing timezones are calculated correctly
     62        'filter-timeuntil06' : ('{{ a|timeuntil }}', {'a': now_tz_i}, '0 minutes'),
     63        'filter-timeuntil07' : ('{{ a|timeuntil:b }}', {'a': now_tz_i, 'b': now_tz}, '0 minutes'),
     64
    5265        'filter-addslash01': ("{% autoescape off %}{{ a|addslashes }} {{ b|addslashes }}{% endautoescape %}", {"a": "<a>'", "b": mark_safe("<a>'")}, ur"<a>\' <a>\'"),
    5366        'filter-addslash02': ("{{ a|addslashes }} {{ b|addslashes }}", {"a": "<a>'", "b": mark_safe("<a>'")}, ur"&lt;a&gt;\&#39; <a>\'"),
    5467
  • tests/regressiontests/utils/timesince.py

     
    11"""
    22>>> from datetime import datetime, timedelta
    3 >>> from django.utils.timesince import timesince
     3>>> from django.utils.timesince import timesince, timeuntil
     4>>> from django.utils.tzinfo import LocalTimezone, FixedOffset
    45
    56>>> t = datetime(2007, 8, 14, 13, 46, 0)
    67
     
    7475u'0 minutes'
    7576>>> timesince(t, t-4*oneday-5*oneminute)
    7677u'0 minutes'
     78
     79# When using two different timezones.
     80>>> now = datetime.now()
     81>>> now_tz = datetime.now(LocalTimezone(now))
     82>>> now_tz_i = datetime.now(FixedOffset((3 * 60) + 15))
     83>>> timesince(now_tz, now_tz_i)
     84u'0 minutes'
     85>>> timeuntil(now_tz, now_tz_i)
     86u'0 minutes'
    7787"""
  • docs/templates.txt

     
    17631763June 2006, and ``comment_date`` is a date instance for 08:00 on 1 June 2006,
    17641764then ``{{ comment_date|timesince:blog_date }}`` would return "8 hours".
    17651765
     1766Comparing offset-naive and offset-aware datetimes will return an empty string.
     1767
    17661768Minutes is the smallest unit used, and "0 minutes" will be returned for any
    17671769date that is in the future relative to the comparison point.
    17681770
     
    17781780the comparison point (instead of *now*). If ``from_date`` contains 22 June
    177917812006, then ``{{ conference_date|timeuntil:from_date }}`` will return "1 week".
    17801782
     1783Comparing offset-naive and offset-aware datetimes will return an empty string.
     1784
    17811785Minutes is the smallest unit used, and "0 minutes" will be returned for any
    17821786date that is in the past relative to the comparison point.
    17831787
Back to Top