From 3950c2f3c5cb9ee66d0edd4a7df5c512b0e28a94 Mon Sep 17 00:00:00 2001
From: Michael Smith <michael@hurts.ca>
Date: Sun, 12 Jun 2005 01:11:11 +0000
Subject: [PATCH] add intersection support

---
 CommandParser.py             | 27 +++++++++++++++++++-------
 PlanLocation.py              | 44 ++++++++++++++++++++++++++++++++++++++++++
 Planner.py                   |  9 ++-------
 mailPlanner.py               |  2 +-
 runplanner.py                |  2 +-
 tests/test_command_parser.py | 46 ++++++++++++++++++++++++++++++++++++++++++++
 6 files changed, 114 insertions(+), 16 deletions(-)
 create mode 100644 PlanLocation.py
 create mode 100755 tests/test_command_parser.py

diff --git a/CommandParser.py b/CommandParser.py
index d65ecca..3e9a974 100644
--- a/CommandParser.py
+++ b/CommandParser.py
@@ -7,11 +7,12 @@ import sre
 import time
 
 import PlanTime
+import PlanLocation
 
 class Command:
     def __init__(self):
-        self.src = None
-        self.dest = None
+        self.start = None
+        self.end = None
         self.time = None
 
 class CommandParseException(Exception):
@@ -24,14 +25,14 @@ class CommandParser:
         self.parse(str)
 
     def parse(self, str):
-        # Look for src and dest at the start of the string.
+        # Look for start and end at the start of the string.
         match = _full_rx.match(str)
         if not match:
             raise CommandParseException("Failed to extract source and "
                                         "destination from command '%s'" % str);
         self.cmd = Command()
-        self.cmd.src = match.group("src")
-        self.cmd.dest = match.group("dest")
+        self.cmd.start = self.parseLocation(match.group("start"))
+        self.cmd.end = self.parseLocation(match.group("end"))
 
         # Now look for time constraints.
         rule = match.group("rule")
@@ -44,6 +45,13 @@ class CommandParser:
             self.cmd.time                   \
                 = PlanTime.PlanTime(self.decodeTime(timestr), ruleMap[rule])
 
+    def parseLocation(self, str):
+        match = _intersection_rx.match(str)
+        if match:
+            return PlanLocation.IntersectionLocation(match.group(1),
+                                                     match.group(2))
+        return PlanLocation.AddressLocation(str)
+
     def decodeTime(self, str):
         match = _time_rx.match(str)
         if not match:
@@ -51,11 +59,16 @@ class CommandParser:
         t = time.localtime()
         return time.mktime(t)
 
-_full_re = ("^\s*(?P<src>.*?)\s+to\s+(?P<dest>.*?)\s*"
+_full_re = ("^\s*(?P<start>.*?)\s+to\s+(?P<end>.*?)\s*"
             # at this point the pattern either ends, or there's a timespec
-            "(?:$|(?P<rule>by|at)\s+(?P<time>.*?)\s*$)")
+            # Require the time to have at least one digit so people can still
+            # use "at" for intersections (although "and" is better)
+            "(?:$|(?P<rule>by|at)\s+(?P<time>\d.+?)\s*$)")
 _full_rx = sre.compile(_full_re)
 
+_intersection_re = "^(.+?)\s+(?:at|and)\s*(.+?)$"
+_intersection_rx = sre.compile(_intersection_re)
+
 # 11:30
 # 11:30 pm
 # 1130 pm
diff --git a/PlanLocation.py b/PlanLocation.py
new file mode 100644
index 0000000..6680a7f
--- /dev/null
+++ b/PlanLocation.py
@@ -0,0 +1,44 @@
+#
+# vi: set softtabstop=4 shiftwidth=4 tabstop=8 expandtab:
+
+class PlanLocation:
+    """Defines a trip endpoint (street address, intersection, etc.)"""
+
+    def getPage(self, isFrom):
+        """Returns a string, e.g. FromAddress.oci"""
+        return self.selectPage(isFrom, self.type)
+
+    def toPlannerParams(self, isFrom):
+        """Returns a tuple of tuples of CGI parameters."""
+        pass
+
+    def selectBase(self, isFrom):
+        return ("to", "from")[isFrom]
+
+    def selectPage(self, isFrom, uctype):
+        """returns e.g. FromAddress.oci"""
+        return "%s%s.oci" % (self.selectBase(isFrom).title(), uctype.title())
+
+    type = None
+
+class AddressLocation(PlanLocation):
+    def __init__(self, address):
+        self.address = address
+
+    def toPlannerParams(self, isFrom):
+        return ((self.selectBase(isFrom) + "Address", self.address),
+                ("streetType", "Other"))
+
+    type = "Address"
+
+class IntersectionLocation(PlanLocation):
+    def __init__(self, street1, street2):
+        self.street1 = street1
+        self.street2 = street2
+
+    def toPlannerParams(self, isFrom):
+        base = self.selectBase(isFrom)
+        return ((base + "OnStreet", self.street1),
+                (base + "AtStreet", self.street2))
+
+    type = "Intersection"
diff --git a/Planner.py b/Planner.py
index b180a36..92591eb 100644
--- a/Planner.py
+++ b/Planner.py
@@ -29,15 +29,10 @@ class TravelPlannerClient:
         r = self._sendRequest(self.START_PAGE, None)
 
     def feedStartLocation(self, loc):
-        # name="tp_fromAddress" method="get" action="FromAddress.oci"
-        # fromAddress text
-        # streetType=Other
-        params = (("fromAddress", loc), ("streetType", "Other"))
-        r = self._sendRequest("FromAddress.oci", params)
+        self._sendRequest(loc.getPage(True), loc.toPlannerParams(True))
 
     def feedEndLocation(self, loc):
-        params = (("toAddress", loc), ("streetType", "Other"))
-        r = self._sendRequest("ToAddress.oci", params)
+        self._sendRequest(loc.getPage(False), loc.toPlannerParams(False))
 
     def feedTime(self, time):
         # name="tp_time" action="SelectTime.oci"
diff --git a/mailPlanner.py b/mailPlanner.py
index a03f52e..773250b 100755
--- a/mailPlanner.py
+++ b/mailPlanner.py
@@ -53,7 +53,7 @@ def handleMessage(msg, replyto):
             cmd.time = PlanTime.PlanTime(time.time() + 180,
                                          PlanTime.MUST_LEAVE_AFTER)
 
-        itin = Planner.plan(cmd.src, cmd.dest, cmd.time)
+        itin = Planner.plan(cmd.start, cmd.end, cmd.time)
         sf = ShortFormatter.ShortFormatter(itin.entries)
 
         sendMessage(MIMEText("\n".join(sf.lines)), replyto)
diff --git a/runplanner.py b/runplanner.py
index 626eba5..ccc2d0f 100755
--- a/runplanner.py
+++ b/runplanner.py
@@ -21,7 +21,7 @@ def main(argv=None):
         cmd.time = PlanTime.PlanTime(time.time() + 180,
                                      PlanTime.MUST_LEAVE_AFTER)
 
-    itin = Planner.plan(cmd.src, cmd.dest, cmd.time)
+    itin = Planner.plan(cmd.start, cmd.end, cmd.time)
     sf = ShortFormatter.ShortFormatter(itin.entries)
 
     print itin.entries
diff --git a/tests/test_command_parser.py b/tests/test_command_parser.py
new file mode 100755
index 0000000..58b1322
--- /dev/null
+++ b/tests/test_command_parser.py
@@ -0,0 +1,46 @@
+#
+# vi: set softtabstop=4 shiftwidth=4 tabstop=8 expandtab:
+
+import sre
+import unittest
+import CommandParser
+
+class TestFullRx(unittest.TestCase):
+
+    def testSimpleAddresses(self):
+        text = "  101 champagne  to   18 auriga    "
+        match = CommandParser._full_rx.match(text)
+        self.assertEquals(match.group("start"), "101 champagne")
+        self.assertEquals(match.group("end"), "18 auriga")
+
+    def testSimpleAddressesWithTime(self):
+        text = "101 champagne to  18 auriga   at 11:30 pm  "
+        match = CommandParser._full_rx.match(text)
+        self.assertEquals(match.group("start"), "101 champagne")
+        self.assertEquals(match.group("end"), "18 auriga")
+        self.assertEquals(match.group("rule"), "at")
+        self.assertEquals(match.group("time"), "11:30 pm")
+
+    def testIntersectionWithAtAsSecondLoc(self):
+        text = "101 champagne to  auriga at antares "
+        match = CommandParser._full_rx.match(text)
+        self.assertEquals(match.group("start"), "101 champagne")
+        self.assertEquals(match.group("end"), "auriga at antares")
+
+    def testIntersectionWithAtAsSecondLocAndTime(self):
+        text = "101 champagne to  auriga at antares  at   130  "
+        match = CommandParser._full_rx.match(text)
+        self.assertEquals(match.group("start"), "101 champagne")
+        self.assertEquals(match.group("end"), "auriga at antares")
+        self.assertEquals(match.group("rule"), "at")
+        self.assertEquals(match.group("time"), "130")
+
+class TestLocationRxes(unittest.TestCase):
+    def testIntersectionRX(self):
+        text = "antares at hunt club"
+        match = CommandParser._intersection_rx.match(text)
+        self.assertEquals(match.group(1), "antares")
+        self.assertEquals(match.group(2), "hunt club")
+
+if __name__ == '__main__':
+    unittest.main()
-- 
2.11.4.GIT