mkm3u: Various refactoring, intertangled.

Make Series aware of their names, and don't keep track separately.  Make
Series aware of their wantedness too.  And abstract out the common
automatic source-disc selection logic from episodes and the new
`!displaced' command.

diff --git a/mkm3u b/mkm3u
index 7cf240c..0078f4d 100755 (executable)
--- a/mkm3u
+++ b/mkm3u
@@ -341,10 +341,11 @@ class MovieSeason (BaseSeason):
     return label
 
 class Series (object):
-  def __init__(me, playlist, title = None):
+  def __init__(me, playlist, name, title = None, wantedp = True):
     me.playlist = playlist
-    me.title = title
+    me.name, me.title = name, title
     me.cur_season = None
+    me.wantedp = wantedp
   def _add_season(me, season):
     me.cur_season = season
   def add_season(me, title, i, implicitp = False):
@@ -420,7 +421,7 @@ class EpisodeListParser (object):
       me._set_mode(MODE_SINGLE)
       try: series = me._series[None]
       except KeyError:
-        series = me._series[None] = Series(me._pl)
+        series = me._series[None] = Series(me._pl, None)
         me._pl.nseries += 1
     else:
       me._set_mode(MODE_MULTI)
@@ -432,10 +433,19 @@ class EpisodeListParser (object):
     for k, v in me._keyvals(opts):
       if k is None: name = v
       else: me._bad_keyval(cmd, k, v)
-    return me._get_series(name), name
+    return me._get_series(name)
 
-  def _wantedp(me, name):
-    return me._series_wanted is None or name in me._series_wanted
+  def _auto_epsrc(me, series):
+    dir = lookup(me._vdirs, series.name, "no active video directory")
+    season = series.ensure_season()
+    check(season.i is not None, "must use explicit iso for movie seasons")
+    vseason = lookup(dir.seasons, season.i,
+                     "season %d not found in video dir `%s'" %
+                       (season.i, dir.dir))
+    src = lookup(vseason.episodes, season.ep_i,
+                 "episode %d.%d not found in video dir `%s'" %
+                   (season.i, season.ep_i, dir.dir))
+    return src
 
   def _process_cmd(me, ww):
 
@@ -453,19 +463,21 @@ class EpisodeListParser (object):
       check(name not in me._series, "series `%s' already defined" % name)
       title = ww.rest(); check(title is not None, "missing title")
       me._set_mode(MODE_MULTI)
-      me._series[name] = Series(me._pl, title)
-      if me._wantedp(name): me._pl.nseries += 1
+      me._series[name] = series = Series(me._pl, name, title,
+                                         me._series_wanted is None or
+                                           name in me._series_wanted)
+      if series.wantedp: me._pl.nseries += 1
 
     elif cmd == "season":
-      series, sname = me._opts_series(cmd, opts)
+      series = me._opts_series(cmd, opts)
       w = ww.nextword();
       check(w is not None, "missing season number")
       if w == "-":
-        if not me._wantedp(sname): return
+        if not series.wantedp: return
         series.add_movies(ww.rest())
       else:
         title = ww.rest(); i = getint(w)
-        if not me._wantedp(sname): return
+        if not series.wantedp: return
         series.add_season(ww.rest(), getint(w), implicitp = False)
       me._cur_episode = me._cur_chapter = None
       me._pl.done_season()
@@ -479,49 +491,40 @@ class EpisodeListParser (object):
       me._pl.epname, me._pl.epnames = name, names
 
     elif cmd == "epno":
-      series, sname = me._opts_series(cmd, opts)
+      series = me._opts_series(cmd, opts)
       w = ww.rest(); check(w is not None, "missing episode number")
       epi = getint(w)
-      if not me._wantedp(sname): return
+      if not series.wantedp: return
       series.ensure_season().ep_i = epi
 
     elif cmd == "iso":
-      _, name = me._opts_series(cmd, opts)
+      series = me._opts_series(cmd, opts)
       fn = ww.rest(); check(fn is not None, "missing filename")
-      if not me._wantedp(name): return
-      if fn == "-": forget(me._isos, name)
+      if not series.wantedp: return
+      if fn == "-": forget(me._isos, series.name)
       else:
         check(OS.path.exists(OS.path.join(ROOT, fn)),
               "iso file `%s' not found" % fn)
-        me._isos[name] = VideoDisc(fn)
+        me._isos[series.name] = VideoDisc(fn)
 
     elif cmd == "vdir":
-      _, name = me._opts_series(cmd, opts)
+      series = me._opts_series(cmd, opts)
       dir = ww.rest(); check(dir is not None, "missing directory")
-      if not me._wantedp(name): return
-      if dir == "-": forget(me._vdirs, name)
-      else: me._vdirs[name] = VideoDir(dir)
+      if not series.wantedp: return
+      if dir == "-": forget(me._vdirs, series.name)
+      else: me._vdirs[series.name] = VideoDir(dir)
 
     elif cmd == "adir":
-      _, name = me._opts_series(cmd, opts)
+      series = me._opts_series(cmd, opts)
       dir = ww.rest(); check(dir is not None, "missing directory")
-      if not me._wantedp(name): return
-      if dir == "-": forget(me._audirs, name)
-      else: me._audirs[name] = AudioDir(dir)
+      if not series.wantedp: return
+      if dir == "-": forget(me._audirs, series.name)
+      else: me._audirs[series.name] = AudioDir(dir)
 
     elif cmd == "displaced":
-      series, name = me._opts_series(cmd, opts)
+      series = me._opts_series(cmd, opts)
       w = ww.rest(); check(w is not None, "missing count"); n = getint(w)
-      check(name not in me._isos, "iso file active")
-      season = series.ensure_season()
-      check(season.i is not None, "movie season active")
-      dir = lookup(me._vdirs, name, "no active video directory")
-      vseason = lookup(dir.seasons, season.i,
-                       "season %d not found in video dir `%s'" %
-                         (season.i, dir.dir))
-      src = lookup(vseason.episodes, season.ep_i,
-                   "episode %d.%d not found in video dir `%s'" %
-                     (season.i, season.ep_i, dir.dir))
+      src = me._auto_epsrc(series)
       src.nuses += n
     else:
       raise ExpectedError("unknown command `%s'" % cmd)
@@ -545,29 +548,20 @@ class EpisodeListParser (object):
     me._cur_chapter = None
 
     title = ww.rest()
-    if not me._wantedp(sname): return
+    if not series.wantedp: return
     season = series.ensure_season()
     if epi is None: epi = season.ep_i
 
     if ti == "-":
       check(season.implicitp, "audio source, but explicit season")
-      if not me._wantedp(sname): return
-      dir = lookup(me._audirs, sname, "no title, and no audio directory")
+      dir = lookup(me._audirs, series.name,
+                   "no title, and no audio directory")
       src = lookup(dir.episodes, season.ep_i,
                    "episode %d not found in audio dir `%s'" % (epi, dir.dir))
 
     else:
-      try: src = me._isos[sname]
-      except KeyError:
-        check(season.i is not None, "must use explicit iso for movies")
-        dir = lookup(me._vdirs, sname,
-                     "title, but no iso or video directory")
-        vseason = lookup(dir.seasons, season.i,
-                         "season %d not found in video dir `%s'" %
-                           (season.i, dir.dir))
-        src = lookup(vseason.episodes, season.ep_i,
-                     "episode %d.%d not found in video dir `%s'" %
-                       (season.i, season.ep_i, dir.dir))
+      try: src = me._isos[series.name]
+      except KeyError: src = me._auto_epsrc(series)
 
     episode = season.add_episode(epi, neps, title, src, ti, ch)
     me._pl.add_episode(episode)
@@ -598,7 +592,7 @@ class EpisodeListParser (object):
   def done(me):
     discs = set()
     for name, vdir in me._vdirs.items():
-      if not me._wantedp(name): continue
+      if not me._series[name].wantedp: continue
       for s in vdir.seasons.values():
         for d in s.episodes.values():
           discs.add(d)