Merge pull request #1 from evdb/master

Django 1.3 compat

.gitignore

@@ -0,0 +1 @@
+*.pyc

fields.py → django_date_extensions/fields.py

@@ -9,8 +9,12 @@
 class ApproximateDate(object):
     """A date object that accepts 0 for month or day to mean we don't
        know when it is within that month/year."""
-    def __init__(self, year, month=0, day=0):
-        if year and month and day:
+    def __init__(self, year=0, month=0, day=0, future=False):
+        if future:
+            d = None
+            if year or month or day:
+                raise ValueError("Future dates can have no year, month or day")
+        elif year and month and day:
             d = date(year, month, day)
         elif year and month:
             d = date(year, month, 1)
@@ -20,45 +24,66 @@ def __init__(self, year, month=0, day=0):
             d = date(year, 1, 1)
         else:
             raise ValueError("You must specify a year")
-        self.year = year
-        self.month = month
-        self.day = day
+
+        self.future = future
+        self.year   = year
+        self.month  = month
+        self.day    = day
 
     def __repr__(self):
-        if self.year and self.month and self.day:
+        if self.future:
+            return 'future'
+        elif self.year and self.month and self.day:
             return "%04d-%02d-%02d" % (self.year, self.month, self.day)
         elif self.year and self.month:
             return "%04d-%02d-00" % (self.year, self.month)
         elif self.year:
             return "%04d-00-00" % self.year
 
     def __str__(self):
-        if self.year and self.month and self.day:
+        if self.future:
+            return 'future'
+        elif self.year and self.month and self.day:
             return dateformat.format(self, "jS F Y")
         elif self.year and self.month:
             return dateformat.format(self, "F Y")
         elif self.year:
             return dateformat.format(self, "Y")
 
+    def __eq__(self, other):
+        if other is None:
+            return False
+        if not isinstance(other, ApproximateDate):
+            return False
+        elif (self.year, self.month, self.day, self.future) != (other.year, other.month, other.day, other.future):
+            return False
+        else:
+            return True
+
     def __lt__(self, other):
-        if other is None or (self.year, self.month, self.day) >= (other.year, other.month, other.day):
+        if other is None:
+            return False
+        elif self.future or other.future:
+            if self.future: 
+                return False   # regardless of other.future it won't be less
+            else:
+                return True    # we were not in future so they are
+        elif(self.year, self.month, self.day) < (other.year, other.month, other.day):
+            return True
+        else:
             return False
-        return True
 
     def __le__(self, other):
-        if other is None or (self.year, self.month, self.day) > (other.year, other.month, other.day):
-            return False
-        return True
+        return self < other or self == other
 
     def __gt__(self, other):
-        if other is None or (self.year, self.month, self.day) <= (other.year, other.month, other.day):
-            return False
-        return True
+        return not self <= other
 
     def __ge__(self, other):
-        if other is None or (self.year, self.month, self.day) < (other.year, other.month, other.day):
-            return False
-        return True
+        return self > other or self == other
+
+    def __len__(self):
+        return len( self.__repr__() )
 
 ansi_date_re = re.compile(r'^\d{4}-\d{1,2}-\d{1,2}$')
 
@@ -78,6 +103,9 @@ def to_python(self, value):
         if isinstance(value, ApproximateDate):
             return value
 
+        if value == 'future':
+            return ApproximateDate(future=True)
+
         if not ansi_date_re.search(value):
             raise ValidationError('Enter a valid date in YYYY-MM-DD format.')
 
@@ -88,13 +116,16 @@ def to_python(self, value):
             msg = _('Invalid date: %s') % _(str(e))
             raise exceptions.ValidationError(msg)
 
-    def get_db_prep_value(self, value):
+    # note - could rename to 'get_prep_value' but would break 1.1 compatability
+    def get_db_prep_value(self, value, connection=None, prepared=False):
         if value in (None, ''):
-                return ''
+            return ''
         if isinstance(value, ApproximateDate):
-                return repr(value)
+            return repr(value)
         if isinstance(value, date):
-                return dateformat.format(value, "Y-m-d")
+            return dateformat.format(value, "Y-m-d")
+        if value == 'future':
+            return 'future'
         if not ansi_date_re.search(value):
             raise ValidationError('Enter a valid date in YYYY-MM-DD format.')
         return value
@@ -137,6 +168,8 @@ def clean(self, value):
         super(ApproximateDateFormField, self).clean(value)
         if value in (None, ''):
             return None
+        if value == 'future':
+            return ApproximateDate(future=True)
         if isinstance(value, ApproximateDate):
             return value
         value = re.sub('(?<=\d)(st|nd|rd|th)', '', value.strip())
@@ -184,6 +217,8 @@ def clean(self, value):
         super(PrettyDateField, self).clean(value)
         if value in (None, ''):
             return None
+        if value == 'future':
+            return ApproximateDate(future=True)
         if isinstance(value, datetime.datetime):
             return value.date()
         if isinstance(value, datetime.date):

django_date_extensions/tests.py

@@ -0,0 +1,75 @@
+import os
+os.environ['DJANGO_SETTINGS_MODULE'] = 'example.settings'
+
+from fields import ApproximateDate
+import unittest
+
+
+class CompareDates(unittest.TestCase):
+
+    def test_compare(self):
+
+        y_past     = ApproximateDate( year=2000 );
+        y_future   = ApproximateDate( year=2100 );
+        future     = ApproximateDate( future=True );
+
+        # check that we can be compared to None, '' and u''
+        for bad_val in ( '', u'', None ):
+            self.assertFalse( y_past in ( bad_val, ) )
+            self.assertFalse( y_past == bad_val      )
+            self.assertTrue(  y_past != bad_val      )
+
+        # sanity check
+        self.assertTrue(  y_past   == y_past   )
+        self.assertTrue(  y_future == y_future )
+
+        self.assertFalse( y_past   != y_past   )
+        self.assertFalse( y_future != y_future )
+
+        self.assertTrue(  y_past   != y_future )
+        self.assertTrue(  y_future != y_past   )
+
+        self.assertTrue(  y_future >  y_past   )
+        self.assertTrue(  y_future >= y_past   )
+        self.assertFalse( y_past   >  y_future )
+        self.assertFalse( y_past   >= y_future )
+
+        self.assertTrue(  y_past   <  y_future )
+        self.assertTrue(  y_past   <= y_future )
+        self.assertFalse( y_future <  y_past   )
+        self.assertFalse( y_future <= y_past   )
+
+        # Future dates are always greater
+        self.assertTrue( y_past   <  future )
+        self.assertTrue( y_past   <= future )
+        self.assertTrue( y_future <  future )
+        self.assertTrue( y_future <= future )
+
+        self.assertTrue( future >  y_past   )
+        self.assertTrue( future >= y_past   )
+        self.assertTrue( future >  y_future )
+        self.assertTrue( future >= y_future )
+
+        # Future dates are equal to themselves (so that sorting is sane)
+        self.assertFalse( future <  future )
+        self.assertTrue(  future <= future )
+        self.assertTrue(  future == future )
+        self.assertTrue(  future >= future )
+        self.assertFalse( future >  future )
+
+
+class Lengths(unittest.TestCase):
+    known_lengths = (
+        ({ 'year':1999,                        }, 10 ),
+        ({ 'year':1999, 'month': 01,           }, 10 ),
+        ({ 'year':1999, 'month': 01, 'day': 01 }, 10 ),
+        ({ 'future': True },                      6  ),
+    );
+
+    def test_length(self):
+        for kwargs, length in self.known_lengths:
+            approx = ApproximateDate( **kwargs )
+            self.assertEqual( len( approx ), length )
+
+if __name__ == "__main__":
+    unittest.main()   

example/ext/fields.py

@@ -1 +1 @@
-../../fields.py
+../../django_date_extensions/fields.py

example/ext/widgets.py

@@ -1 +1 @@
-../../widgets.py
+../../django_date_extensions/widgets.py

setup.py

@@ -0,0 +1,9 @@
+from distutils.core import setup
+
+setup(
+    name='django_date_extensions',
+    version='0.1dev',
+    packages=['django_date_extensions',],
+    license='GNU Affero General Public license',
+    long_description=open('README.txt').read(),
+)