Merge lp:~izidor/gtg/bug-993931 into lp:~gtg/gtg/old-trunk

[Izidor Matušov]

- Added support for due:dd
- pylint likes GTG/tools/dates.py and GTG/tests/test_dates.py now

[Bertrand Rousseau (bertrand-rousseau)]

Seems fine for me, could only spot two tiny things:

 - There's a print statement in GTG/tests/test_dates.py, line 86: "print repr(Date.parse("0101"))" is it intended for the test?
 - in dates.py, "comparsion" variable is mispelled.

review: Needs Information

[lp:~izidor/gtg/bug-993931]

1179. By Izidor Matušov on 2012-05-05

Solving small issues, thanks to Bertrand for noticing them

[Izidor Matušov (izidor)]

I've updated those small details, thansk for catching them!

[Bertrand Rousseau (bertrand-rousseau)]

Ok, good to go!

review: Approve

=== modified file 'CHANGELOG'
--- CHANGELOG	2012-05-02 09:09:23 +0000
+++ CHANGELOG	2012-05-05 04:37:21 +0000
@@ -1,6 +1,7 @@
 2012-0?-?? Getting Things GNOME! 0.3
     * Hide tasks with due date someday, #931376
     * New Date class by Paul Kishimoto and Izidor Matušov
+      * Parse due:3 as next 3rd day in month
     * Urgency Color plugin by Wolter Hellmund
     * Allow GTG to run from different locations than /usr/share or /usr/local/share
     * Removed module GTG.tools.openurl and replaced by python's webbrowser.open

=== modified file 'GTG/tests/test_dates.py'
--- GTG/tests/test_dates.py	2012-03-30 12:44:08 +0000
+++ GTG/tests/test_dates.py	2012-05-05 04:37:21 +0000
@@ -27,12 +27,26 @@
 from GTG import _
 from GTG.tools.dates import Date
 
-class TestDates(unittest.TestCase):
-    '''
-    Tests for the various Date classes
-    '''
+
+def next_month(aday, day=None):
+    """ Increase month, change 2012-02-13 into 2012-03-13.
+    If day is set, replace day in month as well
+
+    @return updated date """
+    if day is None:
+        day = aday.day
+
+    if aday.month == 12:
+        return aday.replace(day=day, month=1, year=aday.year + 1)
+    else:
+        return aday.replace(day=day, month=aday.month + 1)
+
+
+class TestDates(unittest.TestCase): # pylint: disable-msg=R0904
+    """ Tests for the various Date classes """
 
     def test_parse_dates(self):
+        """ Parse common numeric date """
         self.assertEqual(str(Date.parse("1985-03-29")), "1985-03-29")
         self.assertEqual(str(Date.parse("19850329")), "1985-03-29")
         self.assertEqual(str(Date.parse("1985/03/29")), "1985-03-29")
@@ -42,6 +56,7 @@
         self.assertEqual(Date.parse(parse_string), today)
 
     def test_parse_fuzzy_dates(self):
+        """ Parse fuzzy dates like now, soon, later, someday """
         self.assertEqual(Date.parse("now"), Date.now())
         self.assertEqual(Date.parse("soon"), Date.soon())
         self.assertEqual(Date.parse("later"), Date.someday())
@@ -49,6 +64,7 @@
         self.assertEqual(Date.parse(""), Date.no_date())
 
     def test_parse_local_fuzzy_dates(self):
+        """ Parse fuzzy dates in their localized version """
         self.assertEqual(Date.parse(_("now")), Date.now())
         self.assertEqual(Date.parse(_("soon")), Date.soon())
         self.assertEqual(Date.parse(_("later")), Date.someday())
@@ -56,6 +72,7 @@
         self.assertEqual(Date.parse(""), Date.no_date())
 
     def test_parse_fuzzy_dates_str(self):
+        """ Print fuzzy dates in localized version """
         self.assertEqual(str(Date.parse("now")), _("now"))
         self.assertEqual(str(Date.parse("soon")), _("soon"))
         self.assertEqual(str(Date.parse("later")), _("someday"))
@@ -63,8 +80,9 @@
         self.assertEqual(str(Date.parse("")), "")
 
     def test_parse_week_days(self):
+        """ Parse name of week days and don't care about case-sensitivity """
         weekday = date.today().weekday()
-        for i, day in enumerate(['Monday', 'Tuesday', 'Wednesday', 
+        for i, day in enumerate(['Monday', 'Tuesday', 'Wednesday',
             'Thursday', 'Friday', 'Saturday', 'Sunday']):
             if i <= weekday:
                 expected = date.today() + timedelta(7+i-weekday)
@@ -98,10 +116,27 @@
             return
 
         aday = aday.replace(year=aday.year+1, month=1, day=1)
-
         self.assertEqual(Date.parse("0101"), aday)
 
+    def test_on_certain_day(self):
+        """ Parse due:3 as 3rd day this month or next month
+        if it is already more or already 3rd day """
+        for i in range(28):
+            i += 1
+            aday = date.today()
+            if i <= aday.day:
+                aday = next_month(aday, i)
+            else:
+                aday = aday.replace(day=i)
+
+            self.assertEqual(Date.parse(str(i)), aday)
+
+    def test_prevent_regression(self):
+        """ A day represented in GTG Date must be still the same """
+        aday = date.today()
+        self.assertEqual(Date(aday), aday)
+
 
 def test_suite():
+    """ Return unittests """
     return unittest.TestLoader().loadTestsFromTestCase(TestDates)
-

=== modified file 'GTG/tools/dates.py'
--- GTG/tools/dates.py	2012-03-30 12:44:08 +0000
+++ GTG/tools/dates.py	2012-05-05 04:37:21 +0000
@@ -17,6 +17,13 @@
 # this program.  If not, see <http://www.gnu.org/licenses/>.
 # -----------------------------------------------------------------------------
 
+""" General class for representing dates in GTG.
+
+Dates Could be normal like 2012-04-01 or fuzzy like now, soon,
+someday, later or no date.
+
+Date.parse() parses all possible representations of a date. """
+
 import calendar
 import datetime
 import locale
@@ -54,48 +61,57 @@
 }
 # functions giving absolute dates for fuzzy dates + no date
 FUNCS = {
-    NOW: lambda: datetime.date.today(),
-    SOON: lambda: datetime.date.today() + datetime.timedelta(15),
-    SOMEDAY: lambda: datetime.date.max,
-    NODATE: lambda: datetime.date.max - datetime.timedelta(1),
+    NOW: datetime.date.today(),
+    SOON: datetime.date.today() + datetime.timedelta(15),
+    SOMEDAY: datetime.date.max,
+    NODATE: datetime.date.max - datetime.timedelta(1),
 }
 
 # ISO 8601 date format
 ISODATE = '%Y-%m-%d'
 
-def convert_datetime_to_date(dt):
-    return datetime.date(dt.year, dt.month, dt.day)
+
+def convert_datetime_to_date(aday):
+    """ Convert python's datetime to date.
+    Strip unusable time information. """
+    return datetime.date(aday.year, aday.month, aday.day)
+
 
 class Date(object):
     """A date class that supports fuzzy dates.
-    
+
     Date supports all the methods of the standard datetime.date class. A Date
     can be constructed with:
       * the fuzzy strings 'now', 'soon', '' (no date, default), or 'someday'
       * a string containing an ISO format date: YYYY-MM-DD, or
       * a datetime.date or Date instance.
-    
+
     """
     _real_date = None
     _fuzzy = None
 
     def __init__(self, value=''):
+        self._parse_init_value(value)
+
+    def _parse_init_value(self, value):
+        """ Parse many possible values and setup date """
         if value is None:
-            self.__init__(NODATE)
+            self._parse_init_value(NODATE)
         elif isinstance(value, datetime.date):
             self._real_date = value
         elif isinstance(value, Date):
-            self._real_date = value._real_date
-            self._fuzzy = value._fuzzy
+            # Copy internal values from other Date object, make pylint silent
+            self._real_date = value._real_date # pylint: disable-msg=W0212
+            self._fuzzy = value._fuzzy # pylint: disable-msg=W0212
         elif isinstance(value, str) or isinstance(value, unicode):
             try:
-                dt = datetime.datetime.strptime(value, ISODATE).date()
-                self._real_date = convert_datetime_to_date(dt)
+                da_ti = datetime.datetime.strptime(value, ISODATE).date()
+                self._real_date = convert_datetime_to_date(da_ti)
             except ValueError:
                 # it must be a fuzzy date
                 try:
                     value = str(value.lower())
-                    self.__init__(LOOKUP[value])
+                    self._parse_init_value(LOOKUP[value])
                 except KeyError:
                     raise ValueError("Unknown value for date: '%s'" % value)
         elif isinstance(value, int):
@@ -103,46 +119,47 @@
         else:
             raise ValueError("Unknown value for date: '%s'" % value)
 
-    def _date(self):
+    def date(self):
+        """ Map date into real date, i.e. convert fuzzy dates """
         if self.is_fuzzy():
-            return FUNCS[self._fuzzy]()
+            return FUNCS[self._fuzzy]
         else:
             return self._real_date
 
     def __add__(self, other):
         if isinstance(other, datetime.timedelta):
-            return Date(self._date() + other)
+            return Date(self.date() + other)
         else:
             raise NotImplementedError
     __radd__ = __add__
 
     def __sub__(self, other):
-        if hasattr(other, '_date'):
-            return self._date() - other._date()
+        if hasattr(other, 'date'):
+            return self.date() - other.date()
         else:
-            return self._date() - other
+            return self.date() - other
 
     def __rsub__(self, other):
-        if hasattr(other, '_date'):
-            return other._date() - self._date()
+        if hasattr(other, 'date'):
+            return other.date() - self.date()
         else:
-            return other - self._date()
+            return other - self.date()
 
     def __cmp__(self, other):
         """ Compare with other Date instance """
         if isinstance(other, Date):
-            c = cmp(self._date(), other._date())
+            comparison = cmp(self.date(), other.date())
 
             # Keep fuzzy dates below normal dates
-            if c == 0:
+            if comparison == 0:
                 if self.is_fuzzy() and not other.is_fuzzy():
                     return 1
                 elif not self.is_fuzzy() and other.is_fuzzy():
                     return -1
 
-            return c
+            return comparison
         elif isinstance(other, datetime.date):
-            return cmp(self._date(), other)
+            return cmp(self.date(), other)
         else:
             raise NotImplementedError
 
@@ -170,7 +187,7 @@
         try:
             return self.__dict__[name]
         except KeyError:
-            return getattr(self._date(), name)
+            return getattr(self.date(), name)
 
     def is_fuzzy(self):
         """ True if the Date is one of the fuzzy values """
@@ -181,56 +198,95 @@
         if self._fuzzy == NODATE:
             return None
         else:
-            return (self._date() - datetime.date.today()).days
+            return (self.date() - datetime.date.today()).days
 
     @classmethod
     def today(cls):
+        """ Return date for today """
         return Date(datetime.date.today())
 
     @classmethod
     def tomorrow(cls):
+        """ Return date for tomorrow """
         return Date(datetime.date.today() + datetime.timedelta(1))
 
     @classmethod
     def now(cls):
+        """ Return date representing fuzzy date now """
         return Date(NOW)
 
     @classmethod
     def no_date(cls):
+        """ Return date representing no (set) date """
         return Date(NODATE)
 
     @classmethod
     def soon(cls):
+        """ Return date representing fuzzy date soon """
         return Date(SOON)
 
     @classmethod
     def someday(cls):
+        """ Return date representing fuzzy date someday """
         return Date(SOMEDAY)
 
     @classmethod
-    def parse(cls, string):
-        """Return a Date corresponding to string, or None.
-        
-        string may be in one of the following formats:
-         * YYYY/MM/DD, YYYYMMDD, MMDD
-         * fuzzy dates
-         * 'today', 'tomorrow', 'next week', 'next month' or 'next year' in
-           English or the system locale.
-        """
-        # sanitize input
-        if string is None:
-            string = ''
-        else:
-            string = string.lower()
-
-        # try the default formats
-        try:
-            return Date(string)
-        except ValueError:
-            pass
-
+    def _parse_only_month_day(cls, string):
+        """ Parse next Xth day in month """
+        try:
+            mday = int(string)
+            if not 1 <= mday <= 31 or string.startswith('0'):
+                return None
+        except ValueError:
+            return None
+
+        today = datetime.date.today()
+        try:
+            result = today.replace(day=mday)
+        except ValueError:
+            result = None
+
+        if result is None or result <= today:
+            if today.month == 12:
+                next_month = 1
+                next_year = today.year + 1
+            else:
+                next_month = today.month + 1
+                next_year = today.year
+
+            try:
+                result = datetime.date(next_year, next_month, mday)
+            except ValueError:
+                pass
+
+        return result
+
+    @classmethod
+    def _parse_numerical_format(cls, string):
+        """ Parse numerical formats like %Y/%m/%d, %Y%m%d or %m%d """
         result = None
         today = datetime.date.today()
+        for fmt in ['%Y/%m/%d', '%Y%m%d', '%m%d']:
+            try:
+                da_ti = datetime.datetime.strptime(string, fmt)
+                result = convert_datetime_to_date(da_ti)
+                if '%Y' not in fmt:
+                    # If the day has passed, assume the next year
+                    if result.month > today.month or \
+                        (result.month == today.month and
+                        result.day >= today.day):
+                        year = today.year
+                    else:
+                        year = today.year +1
+                    result = result.replace(year=year)
+            except ValueError:
+                continue
+        return result
+
+    @classmethod
+    def _parse_text_representation(cls, string):
+        """ Match common text representation for date """
+        today = datetime.date.today()
 
         # accepted date formats
         formats = {
@@ -260,32 +316,54 @@
             formats[english.lower()] = offset
             formats[local.lower()] = offset
 
-        # attempt to parse the string with known formats
-        for fmt in ['%Y/%m/%d', '%Y%m%d', '%m%d']:
-            try: 
-                dt = datetime.datetime.strptime(string, fmt)
-                result = convert_datetime_to_date(dt)
-                if '%Y' not in fmt:
-                    # If the day has passed, assume the next year
-                    if result.month > today.month or \
-                        (result.month == today.month and result.day >= today.day):
-                        year = today.year
-                    else:
-                        year = today.year +1
-                    result = result.replace(year=year)
-            except ValueError:
-                continue
-
         offset = formats.get(string, None)
-        if result is None and offset is not None:
-            result = today + datetime.timedelta(offset)
-
+        if offset is None:
+            return None
+        else:
+            return today + datetime.timedelta(offset)
+
+    @classmethod
+    def parse(cls, string):
+        """Return a Date corresponding to string, or None.
+
+        string may be in one of the following formats:
+         * YYYY/MM/DD, YYYYMMDD, MMDD, D
+         * fuzzy dates
+         * 'today', 'tomorrow', 'next week', 'next month' or 'next year' in
+           English or the system locale.
+        """
+        # sanitize input
+        if string is None:
+            string = ''
+        else:
+            string = string.lower()
+
+        # try the default formats
+        try:
+            return Date(string)
+        except ValueError:
+            pass
+
+        # do several parsing
+        result = cls._parse_only_month_day(string)
+        if result is None:
+            result = cls._parse_numerical_format(string)
+        if result is None:
+            result = cls._parse_text_representation(string)
+
+        # Announce the result
         if result is not None:
             return Date(result)
         else:
             raise ValueError("Can't parse date '%s'" % string)
 
     def to_readable_string(self):
+        """ Return nice representation of date.
+
+        Fuzzy dates => localized version
+        Close dates => Today, Tomorrow, In X days
+        Other => with locale dateformat, stripping year for this year
+        """
         if self._fuzzy is not None:
             return STRINGS[self._fuzzy]
 
@@ -307,6 +385,6 @@
                 year_len = 365
             if float(days_left) / year_len < 1.0:
                 #if it's in less than a year, don't show the year field
-                locale_format = locale_format.replace('/%Y','')
-                locale_format = locale_format.replace('.%Y','.')
+                locale_format = locale_format.replace('/%Y', '')
+                locale_format = locale_format.replace('.%Y', '.')
             return  self._real_date.strftime(locale_format)