ChatLogTracker._onboard_event takes a vessel argument

[ypp-sc-tools.db-test.git] / yoweb-scrape

diff --git a/yoweb-scrape b/yoweb-scrape
index 577b3b8d50234349760b2c5b4b58d6da5aba461a..93ce3177b59d5370da7b90544b9bd21a98ec5990 100755 (executable)
--- a/yoweb-scrape
+++ b/yoweb-scrape
@@ -423,7 +423,7 @@ class ChatLogTracker:
        def __init__(self, myself_pi, logfn):
                self._pl = {}   # self._pl['Pirate'] =
                self._vl = {}   #   self._vl['Vessel']['Pirate'] = PirateAboard
-                               # self._vl['Vessel']['#lastaboard']
+                               # self._vl['Vessel']['#lastinfo']
                self._v = None          # self._v =
                self._vessel = None     #       self._vl[self._vessel]
                self._date = None
@@ -436,18 +436,17 @@ class ChatLogTracker:
        def force_redisplay(self):
                self._need_redisplay = True
 
-       def _onboard_event(self,timestamp,pirate,event):
-               try: pa = self._pl[pirate]
-               except KeyError: pa = None
-               if pa is not None and pa.v is self._v:
+       def _onboard_event(self,v,timestamp,pirate,event):
+               pa = self._pl.get(pirate, None)
+               if pa is not None and pa.v is v:
                        pa.last_time = timestamp
                        pa.last_event = event
                else:
                        if pa is not None: del pa.v[pirate]
-                       pa = PirateAboard(pirate, self._v, timestamp, event)
+                       pa = PirateAboard(pirate, v, timestamp, event)
                        self._pl[pirate] = pa
-                       self._v[pirate] = pa
-               self._v['#lastaboard'] = timestamp
+                       v[pirate] = pa
+               v['#lastinfo'] = timestamp
                self.force_redisplay()
                return pa
 
@@ -459,18 +458,29 @@ class ChatLogTracker:
 
        def expire_garbage(self, timestamp):
                for (vn,v) in list(self._vl.iteritems()):
-                       la = v['#lastaboard']
+                       la = v['#lastinfo']
                        if timestamp - la > opts.ship_reboard_clearout:
                                self._debug_line_disposition(timestamp,'',
                                        'stale reset '+vn)
                                self._trash_vessel(v)
                                del self._vl[vn]
 
-       def clear_vessel(self, timestamp):
-               if self._v is not None:
-                       self._trash_vessel(self._v)
-               self._v = {'#lastaboard': timestamp}
-               self._vl[self._vessel] = self._v
+       def _create_vessel(self, vn, timestamp):
+               self._vl[vn] = v = { '#lastinfo': timestamp }
+               return v
+
+       def _update_vessel_lookup(self, vn, timestamp, dml):
+               v = self._vl.get(vn, None)
+               if v is None:
+                       dml.append('new')
+                       v = self._create_vessel(vn, timestamp)
+               elif timestamp - v['#lastinfo'] > opts.ship_reboard_clearout:
+                       dml.append('stale')
+                       self._trash_vessel(v)
+                       v = self._create_vessel(vn, timestamp)
+               else:
+                       dml.append('current')
+               return v
 
        def _debug_line_disposition(self,timestamp,l,m):
                debug('CLT %13s %-30s %s' % (timestamp,m,l))
@@ -507,35 +517,27 @@ class ChatLogTracker:
 
                l = l[l.find(' ')+1:]
 
-               def ob_x(who,event):
-                       return self._onboard_event(timestamp, who, event)
+               def ob_x(pirate,event):
+                       return self._onboard_event(
+                                       self._v, timestamp, pirate, event)
                def ob1(did): ob_x(m.group(1), did); return d(did)
                def oba(did): return ob1('%s %s' % (did, m.group(2)))
 
-               def disembark(who, how):
-                       ob_x(who, 'leaving '+how)
-                       del self._v[who]
-                       del self._pl[who]
+               def disembark(pirate, event):
+                       ob_x(pirate, 'leaving '+event)
+                       del self._v[pirate]
+                       del self._pl[pirate]
 
                m = rm('Going aboard the (\\S.*\\S)\\.\\.\\.$')
                if m:
+                       dm = ['boarding']
                        pn = self._myself.name
-                       self._vessel = m.group(1)
-                       dm = 'boarding'
-
-                       try:             self._v = self._vl[self._vessel]
-                       except KeyError: self._v = None; dm += ' new'
-                       
-                       if self._v is not None:  la = self._v['#lastaboard']
-                       else:                    la = 0; dm += ' ?la'
-
-                       if timestamp - la > opts.ship_reboard_clearout:
-                               self.clear_vessel(timestamp)
-                               dm += ' stale'
+                       self._vessel = vn = m.group(1)
+                       self._v = self._update_vessel_lookup(vn, timestamp, dm)
 
                        ob_x(pn, 'we boarded')
                        self.expire_garbage(timestamp)
-                       return d(dm)
+                       return d(' '.join(dm))
 
                if self._v is None:
                        return d('no vessel')
@@ -632,8 +634,8 @@ class ChatLogTracker:
        def _str_vessel(self, vn, v):
                s = ' vessel %s\n' % vn
                s += ' '*20 + "%-*s   %13s\n" % (
-                               max_pirate_namelen, '#lastaboard',
-                               v['#lastaboard'])
+                               max_pirate_namelen, '#lastinfo',
+                               v['#lastinfo'])
                for pn in sorted(v.keys()):
                        if pn.startswith('#'): continue
                        pa = v[pn]