From 41af0a769e8896b6df5baccfff31d5ccea3f7da8 Mon Sep 17 00:00:00 2001
From: Markus Holtermann <info@markusholtermann.eu>
Date: Wed, 30 Jan 2013 20:00:14 +0100
Subject: Add total order for ``bvggrabber.api.Departure``. Fixes #1

---
 bvggrabber/api/__init__.py | 33 +++++++++++++++++++++++++-----
 tests/test_api.py          | 51 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 79 insertions(+), 5 deletions(-)

diff --git a/bvggrabber/api/__init__.py b/bvggrabber/api/__init__.py
index ed5ca3f..8568d00 100644
--- a/bvggrabber/api/__init__.py
+++ b/bvggrabber/api/__init__.py
@@ -3,7 +3,9 @@ import datetime
 import json
 import re
 
+from functools import total_ordering
 from math import ceil, floor
+
 from dateutil.parser import parse
 
 
@@ -30,6 +32,7 @@ class QueryApi(object):
                                   "the call() method!")
 
 
+@total_ordering
 class Departure(object):
 
     def __init__(self, start, end, when, line, since=None):
@@ -54,11 +57,6 @@ class Departure(object):
             raise TypeError("when must be a valid datetime, timestamp or "
                             "string!")
 
-    def __str__(self):
-        return "Start: %s, End: %s, when: %s, now: %s, line: %s" % (
-            self.start, self.end, hourformat(self.when),
-            hourformat(self.now), self.line)
-
     @property
     def remaining(self):
         return compute_remaining(self.now, self.when)
@@ -73,3 +71,28 @@ class Departure(object):
                            'when_full': fullformat(self.when),
                            'when_hour': hourformat(self.when),
                            'remaining': round(self.remaining)})
+
+    def __eq__(self, other):
+        """Two departures are assumed to be equal iff their remaining time
+        and their destination are equal.
+
+        Right now we do **not** considering the start or line, since that would
+        require some kind of geo location in order to define a *total order*.
+        """
+        return ((self.remaining, self.end.lower()) ==
+                (other.remaining, other.end.lower()))
+
+    def __lt__(self, other):
+        """A departure is assumed to be less than another iff its remaining
+        time is less than the remaining time of the other departure.
+
+        Right now we do **not** considering the start, end or line, since that
+        would require some kind of geo location in order to define a *total
+        order*.
+        """
+        return (remaining < other.remaining)
+
+    def __str__(self):
+        return "Start: %s, End: %s, when: %s, now: %s, line: %s" % (
+            self.start, self.end, hourformat(self.when),
+            hourformat(self.now), self.line)
diff --git a/tests/test_api.py b/tests/test_api.py
index 68e797b..778b9b8 100644
--- a/tests/test_api.py
+++ b/tests/test_api.py
@@ -221,3 +221,54 @@ class TestDeparture(BaseTestDeparture):
         str2 = "Start: From My Station, End: To Your Station, when: 03:05, " \
                "now: 03:04, line: A Line"
         self.assertEqual(str2, str(dep2))
+
+
+class TestDepartureTotalOrder(unittest.TestCase):
+
+    def setUp(self):
+        self.td = datetime.timedelta(minutes=1)
+
+        self.dt_now1 = datetime.datetime(2013, 1, 2, 3, 4, 1)
+        self.dt_now2 = datetime.datetime(2013, 1, 2, 3, 4, 1)
+        self.dt_earlier = datetime.datetime(2013, 1, 2, 3, 4, 1) - self.td
+        self.dt_later = datetime.datetime(2013, 1, 2, 3, 4, 1) + self.td
+
+    def test_equal(self):
+        self.assertEqual(self.dt_now1, self.dt_now2)
+
+    def test_less(self):
+        self.assertLess(self.dt_earlier, self.dt_now1)
+        self.assertLess(self.dt_earlier, self.dt_later)
+        self.assertLess(self.dt_now1, self.dt_later)
+
+    def test_greater(self):
+        self.assertGreater(self.dt_now1, self.dt_earlier)
+        self.assertGreater(self.dt_later, self.dt_earlier)
+        self.assertGreater(self.dt_later, self.dt_now1)
+
+    def test_not_equal(self):
+        self.assertNotEqual(self.dt_now1, self.dt_earlier)
+        self.assertNotEqual(self.dt_now1, self.dt_later)
+        self.assertNotEqual(self.dt_now2, self.dt_earlier)
+        self.assertNotEqual(self.dt_now2, self.dt_later)
+        self.assertNotEqual(self.dt_earlier, self.dt_later)
+
+    def test_sorting_single(self):
+        l = [self.dt_now1, self.dt_later, self.dt_earlier]
+        self.assertEqual([self.dt_earlier, self.dt_now1, self.dt_later],
+                        sorted(l))
+        self.assertEqual([self.dt_later, self.dt_now1, self.dt_earlier],
+                        sorted(l, reverse=True))
+
+    def test_sorting_multiple(self):
+        l = [self.dt_now1, self.dt_earlier, self.dt_later,
+             self.dt_now2, self.dt_later, self.dt_earlier,
+             self.dt_earlier, self.dt_later, self.dt_now2]
+        self.assertEqual([self.dt_earlier, self.dt_earlier, self.dt_earlier,
+                          self.dt_now1, self.dt_now2, self.dt_now2,
+                          self.dt_later, self.dt_later, self.dt_later],
+                        sorted(l))
+        self.assertEqual([self.dt_later, self.dt_later, self.dt_later,
+                          self.dt_now1, self.dt_now2, self.dt_now2,
+                          self.dt_earlier, self.dt_earlier, self.dt_earlier],
+                        sorted(l, reverse=True))
-- 
cgit v1.2.3