Merge lp:~renamer-developers/renamer/ditch-metalanguage into lp:renamer

[Jonathan Jacobs]

I think the value of the metalanguage has outlived itself and real Python plugins are probably a lot more useful and easy to write. The crazy config file system is also dead.

Some new features (such as creating symlinks and allowing renaming/moving across filesystem boundaries) are present too.

There really should be some more tests but I can't quite figure out where to start.

The flags "--link-dst" and "--link-src" might be more intuitive if they were named "--link-new" and "--link-original" or similar.

[lp:~renamer-developers/renamer/ditch-metalanguage]

95. By Jonathan Jacobs on 2010-09-29

Remove empty scripts directory.

96. By Jonathan Jacobs on 2010-09-29

Remove legacy code.

97. By Jonathan Jacobs on 2010-09-29

Improve logging.

98. By Jonathan Jacobs on 2010-09-29

Add more TV Rage test data.

99. By Jonathan Jacobs on 2010-10-01

Tweak setup.py.

100. By Jonathan Jacobs on 2010-10-01

Update LICENSE.

101. By Jonathan Jacobs on 2010-10-01

Helper symlinker function.

102. By Jonathan Jacobs on 2010-10-01

Tests for renamer.util.

103. By Jonathan Jacobs on 2010-10-01

More tests for renamer.plugins.tv.

104. By Jonathan Jacobs on 2010-10-01

Tests, tweaks and docs.

105. By Jonathan Jacobs on 2010-10-01

Docstring.

106. By Jonathan Jacobs on 2010-10-01

Fix pyflakes warnings.

[Andrew Snowden (andrew-snowden)]

Everything looks good, the only suggested change was to move the filename parsing out of the TVRage class into a base TV class so that it could be shared by any other metadata sources (e.g. thetvdb.com) since it isn't specific to TVRage. That can wait until there is actually another source implemented.

review: Approve

[Tristan Seligmann (mithrandi)]

> 24 from renamer._version import version
> 25 +version # Ssssh, Pyflakes.

Don't do this, use __all__ instead.

> 124 + ('dry-run', 'n', 'Perform a dry-run.'),

It might be more intuitive to make the long option name be --no-act.

> 6 +Copyright © 2007-2010 Slipgate Development cc

There isn't really such an entity as Slipgate Development cc.

> 234 + self.args = (FilePath(arg) for arg in args)

This should probably be a listcomp, not a genexp.

> 1033 +class _metaASC(type):

"ASC" stands for AxiomaticSubCommand, and thus isn't a very appropriate name here.

review: Needs Fixing

[Tristan Seligmann (mithrandi)]

148 + return (get,)
149 +
150 + subCommands = property(*subCommands())

This is a bit pointless, just use @property on the inner function and be done.

review: Needs Fixing

[lp:~renamer-developers/renamer/ditch-metalanguage]

107. By Jonathan Jacobs on 2010-10-05

Simplify subCommands property.

108. By Jonathan Jacobs on 2010-10-05

Use __all__ to shut Pyflakes up, where possible.

109. By Jonathan Jacobs on 2010-10-05

Make copyright information less fictional.

110. By Jonathan Jacobs on 2010-10-05

Change dry run long option name and descriptionn to be more intuitive.

111. By Jonathan Jacobs on 2010-10-05

Store command arguments in a list instead of a generator.

112. By Jonathan Jacobs on 2010-10-05

Replace _metaASC with something more generic.

113. By Jonathan Jacobs on 2010-10-05

Doc tweak.

[Jonathan Jacobs (jjacobs)]

Address review commentary.

[Tristan Seligmann (mithrandi)]

2397 + if not (newcls.__name__ == typeName and
2398 + newcls.__module__ == moduleName):
2399 + directlyProvides(newcls, *provides)
2400 + return newcls

Okay, so. This should be alsoProvides() instead of directlyProvides(). You can also ditch the if check; instead, just throw in a noLongerProvides() after the definition of EridanusCommand to remove those interfaces from it. Finally, I think instead of this being a factory function that takes some params, it should just be a subclass of type that reads the list of interfaces off an attribute; then you just subclass it and define the interfaces as a class attribute.

2341 + if e.errno == errno.EXDEV:
2342 + raise errors.DifferentLogicalDevices(
2343 + 'Refusing to symlink "%s" to "%s" on another filesystem' % (
2344 + src.path, dst.path))

I don't understand this code at all; when would it be valid for symlink to fail with EXDEV?

1682 + key, value = line.strip().split(u'@', 1)
1683 + data[key] = value.split(u'^')

The page data is returned as a byte string, so splitting on unicode strings here is wrong.

Whew. I hope that's all!

review: Needs Fixing

[lp:~renamer-developers/renamer/ditch-metalanguage]

114. By Jonathan Jacobs on 2010-10-10

Remove crackful EXDEV-handling symlink helper.

115. By Jonathan Jacobs on 2010-10-10

Don't split byte strings on unicode strings.

116. By Jonathan Jacobs on 2010-10-10

Replace DirectlyProvidingMetaclass insanity with something slightly less insane.

[Jonathan Jacobs (jjacobs)]

> Whew. I hope that's all!

Fixed.

[Tristan Seligmann (mithrandi)]

review: Approve

=== modified file 'LICENSE'
--- LICENSE	2009-05-06 10:38:07 +0000
+++ LICENSE	2010-10-10 11:27:40 +0000
@@ -1,4 +1,8 @@
-Copyright © 2007-2009 Slipgate Development cc
+Copyright © 2007-2010
+Andrew Snowden
+Jeremy Thurgood
+Jonathan Jacobs
+Tristan Seligmann
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

=== modified file 'bin/rn'
--- bin/rn	2009-05-06 21:51:47 +0000
+++ bin/rn	2010-10-10 11:27:40 +0000
@@ -1,3 +1,3 @@
-#!/usr/bin/env python2.5
+#!/usr/bin/env python
 from renamer.main import main
 main()

=== modified file 'renamer/__init__.py'
--- renamer/__init__.py	2009-04-29 00:02:05 +0000
+++ renamer/__init__.py	2010-10-10 11:27:40 +0000
@@ -1,1 +1,3 @@
 from renamer._version import version
+
+__all__ = ['version']

=== modified file 'renamer/application.py'
--- renamer/application.py	2009-05-04 15:41:21 +0000
+++ renamer/application.py	2010-10-10 11:27:40 +0000
@@ -1,273 +1,198 @@
 """
 Renamer application logic.
 """
-import glob, os, stat, sys, time
+import glob
+import os
+import string
+import sys
 
-from twisted.internet import reactor
-from twisted.internet.defer import DeferredSemaphore, succeed
-from twisted.internet.stdio import StandardIO
-from twisted.protocols.basic import LineReceiver
+from twisted.internet import reactor, defer
 from twisted.python import usage
-from twisted.python.versions import getVersionString
-
-from renamer import version, logging
-from renamer.env import Environment, EnvironmentMode
-from renamer.util import parallel
-
-
-class ArgumentSorter(object):
-    """
-    Sort arguments according to a certain method.
-    """
-
-    @classmethod
-    def byMtime(cls, path):
-        """
-        Sort according to modification time.
-        """
-        try:
-            return time.localtime(os.stat(path)[stat.ST_MTIME])
-        except OSError:
-            return -1
-
-    @classmethod
-    def bySize(cls, path):
-        """
-        Sort according to file size.
-        """
-        try:
-            return os.stat(path)[stat.ST_SIZE]
-        except OSError:
-            return -1
-
-    @classmethod
-    def byName(cls, path):
-        """
-        Sort according to file name.
-        """
-        return path
-
-    @classmethod
-    def sort(cls, names, method):
-        """
-        Sort names according to a given method.
-
-        @type names: C{list}
-
-        @type method: C{str}
-        """
-        _sortMethods = {
-            'time': cls.byMtime,
-            'size': cls.bySize,
-            'name': cls.byName}
-        names.sort(key=_sortMethods[method])
-
-
-class Options(usage.Options):
-    """
-    Renamer command-line arguments.
-    """
-    synopsis = '[options] argument [argument ...]'
+from twisted.python.filepath import FilePath
+
+from renamer import logging, plugin, util
+
+
+
+class Options(usage.Options, plugin.RenamerSubCommandMixin):
+    synopsis = '[options] command argument [argument ...]'
+
 
     optFlags = [
-        ['glob',    'g', 'Expand arguments as UNIX-style globs'],
-        ['move',    'm', 'Move files'],
-        ['reverse', 'R', 'Reverse sorting order'],
-        ['dry-run', 't', 'Perform a dry-run'],
-        ]
+        ('glob',            'g',  'Expand arguments as UNIX-style globs.'),
+        ('one-file-system', 'x',  "Don't cross filesystems."),
+        ('no-act',          'n',  'Perform a trial run with no changes made.'),
+        ('link-src',        None, 'Create a symlink at the source.'),
+        ('link-dst',        None, 'Create a symlink at the destination.')]
+
 
     optParameters = [
-        ['script',  's', None,   'Renamer script to execute'],
-        ['sort',    'S', 'name', 'Sort filenames by criteria: name, size, time']
-        ]
+        ('name',   'e', None,
+         'Formatted filename.', string.Template),
+        ('prefix', 'p', None,
+         'Formatted path to prefix to files before renaming.', string.Template),
+        ('concurrent', 'l',  10,
+         'Maximum number of concurrent tasks to perform at a time.', int)]
+
+
+    @property
+    def subCommands(self):
+        for plg in plugin.getPlugins():
+            try:
+                yield plg.name, None, plg, plg.description
+            except AttributeError:
+                raise RuntimeError('Malformed plugin: %r' % (plg,))
+
 
     def __init__(self):
         usage.Options.__init__(self)
         self['verbosity'] = 1
 
+
     def opt_verbose(self):
         """
-        Increase output
+        Increase output, use more times for greater effect.
         """
         self['verbosity'] = self['verbosity'] + 1
 
     opt_v = opt_verbose
 
+
     def opt_quiet(self):
         """
-        Suppress output
+        Suppress output.
         """
         self['verbosity'] = self['verbosity'] - 1
 
     opt_q = opt_quiet
 
-    def sortArguments(self, targets):
-        """
-        Sort arguments according to options.
-        """
-        if self['sort']:
-            ArgumentSorter.sort(targets, self['sort'])
-        if self['reverse']:
-            targets.reverse()
-        return targets
 
-    def glob(self, targets):
+    def glob(self, args):
         """
         Glob arguments.
         """
         def _glob():
-            return [target for _target in targets
-                           for target in glob.glob(_target)]
+            return (arg
+                for _arg in args
+                for arg in glob.glob(_arg))
 
         def _globWin32():
-            _targets = []
-            for target in targets:
-                if not os.path.exists(target):
-                    globbed = glob.glob(target)
+            for arg in args:
+                if not os.path.exists(arg):
+                    globbed = glob.glob(arg)
                     if globbed:
-                        _targets.extend(globbed)
+                        for a in globbed:
+                            yield a
                         continue
-
-                _targets.append(target)
-            return _targets
+                yield arg
 
         if sys.platform == 'win32':
             return _globWin32()
         return _glob()
 
-    def parseArgs(self, *targets):
-        """
-        Parse command-line arguments.
-        """
-        if self['script'] and len(targets) == 0:
-            raise usage.UsageError('Too few arguments')
 
+    def parseArgs(self, *args):
+        args = (self.decodeCommandLine(arg) for arg in args)
         if self['glob']:
-            targets = self.glob(targets)
-        self.targets = self.sortArguments(list(targets))
+            args = self.glob(args)
+        self.args = [FilePath(arg) for arg in args]
+
 
 
 class Renamer(object):
-    def __init__(self, options, maxConcurrentScripts=10):
-        """
-        Initialise a Renamer.
-
-        @type options: L{Options}
-        @param options: Parsed command-line options
-
-        @type maxConcurrentScripts: C{int}
-        @param maxConcurrentScripts: Maximum number of scripts to execute in
-            parallel, defaults to 10
-        """
+    """
+    Renamer main logic.
+
+    @type options: L{renamer.application.Options}
+    @ivar options: Parsed command-line options.
+    """
+    def __init__(self, options):
         self.options = options
-        self.maxConcurrentScripts = maxConcurrentScripts
-        self.targets = options.targets
-
-    def createEnvironment(self, args):
-        """
-        Create a new environment.
-
-        @type args: C{iterable}
-        @param args: Initial stack arguments
-        """
-        mode = EnvironmentMode(dryrun=self.options['dry-run'],
-                               move=self.options['move'])
-        return Environment(args,
-                           mode=mode,
-                           verbosity=self.options['verbosity'])
+
+
+    def rename(self, dst, src):
+        """
+        Rename C{src} to {dst}.
+
+        Perform symlinking if specified and create any required directory
+        hiearchy.
+        """
+        options = self.options
+
+        if options['dry-run']:
+            logging.msg('Dry-run: %s => %s' % (src.path, dst.path))
+            return
+
+        if src == dst:
+            logging.msg('Skipping noop "%s"' % (src.path,), verbosity=2)
+            return
+
+        if dst.exists():
+            logging.msg('Refusing to clobber existing file "%s"' % (
+                dst.path,))
+            return
+
+        parent = dst.parent()
+        if not parent.exists():
+            logging.msg('Creating directory structure for "%s"' % (
+                parent.path,), verbosity=2)
+            parent.makedirs()
+
+        # Linking at the destination requires no moving.
+        if options['link-dst']:
+            logging.msg('Symlink: %s => %s' % (src.path, dst.path))
+            src.linkTo(dst)
+        else:
+            logging.msg('Move: %s => %s' % (src.path, dst.path))
+            util.rename(src, dst, oneFileSystem=options['one-file-system'])
+            if options['link-src']:
+                logging.msg('Symlink: %s => %s' % (dst.path, src.path))
+                dst.linkTo(src)
+
+
+    def _processOne(self, src):
+        logging.msg('Processing "%s"' % (src.path,),
+                    verbosity=3)
+        command = self.options.command
+
+        def buildDestination(mapping):
+            prefixTemplate = self.options['prefix']
+            if prefixTemplate is None:
+                prefixTemplate = command.defaultPrefixTemplate
+
+            if prefixTemplate is not None:
+                prefix = os.path.expanduser(
+                    prefixTemplate.safe_substitute(mapping))
+            else:
+                prefixTemplate = string.Template(src.dirname())
+                prefix = prefixTemplate.template
+
+            ext = src.splitext()[-1]
+
+            nameTemplate = self.options['name']
+            if nameTemplate is None:
+                nameTemplate = command.defaultNameTemplate
+
+            filename = nameTemplate.safe_substitute(mapping)
+            logging.msg(
+                'Building filename: prefix=%r  name=%r  mapping=%r' % (
+                    prefixTemplate.template, nameTemplate.template, mapping),
+                verbosity=3)
+            return FilePath(prefix).child(filename).siblingExtension(ext)
+
+        d = defer.maybeDeferred(command.processArgument, src)
+        d.addCallback(buildDestination)
+        d.addCallback(self.rename, src)
+        return d
+
 
     def run(self):
-        """
-        Start running.
-
-        If the script option was used, the script is run for all command-line
-        arguments, and afterwards execution will stop. Otherwise interactive
-        mode is initiated.
-        """
-        if self.options['script']:
-            self.runScript(self.options['script']
-                ).addErrback(logging.err
-                ).addCallback(lambda result: reactor.stop())
-        else:
-            self.runInteractive()
-
-    def runScript(self, script):
-        """
-        Run the given script in the environent.
-
-        The script is executed for each command-line argument, in parallel, up
-        to a maximum of L{maxConcurrentScripts}.
-        """
-        def _runScript(target):
-            env = self.createEnvironment([target])
-            return env.runScript(script)
-
-        return parallel(self.targets, self.maxConcurrentScripts, _runScript)
-
-    def runInteractive(self):
-        """
-        Begin interactive mode.
-
-        Interactive mode is ended with an EOF.
-        """
-        env = self.createEnvironment(self.targets)
-        StandardIO(RenamerInteractive(env))
-
-
-class RenamerInteractive(LineReceiver):
-    """
-    Interactive Renamer session.
-
-    @type semaphore: C{twisted.internet.defer.DeferredSemaphore}
-    @ivar semaphore: Semaphore for serializing command execution
-    """
-    delimiter = os.linesep
-
-    def __init__(self, env):
-        """
-        Initialise an interactive Renamer environment.
-
-        @type env: L{Environment}
-        @param env: Renamer environment for the interactive session
-        """
-        self.env = env
-        self.semaphore = DeferredSemaphore(tokens=1)
-
-    def heading(self):
-        """
-        Display application header.
-        """
-        self.transport.write(getVersionString(version) + self.delimiter)
-
-    def prompt(self):
-        """
-        Display application prompt.
-        """
-        self.transport.write('rn> ')
-
-    def connectionMade(self):
-        self.heading()
-        self.prompt()
-
-    def connectionLost(self, reason):
-        reactor.stop()
-
-    def lineReceived(self, line):
-        def _doLine(result):
-            return self.env.execute(line)
-
-        def maybeQuit(f):
-            f.trap(EOFError)
-            self.transport.loseConnection()
-
-        d = succeed(None)
-
-        line = line.strip()
-        if line:
-            d = self.semaphore.acquire(
-                ).addCallback(_doLine
-                ).addErrback(maybeQuit
-                ).addErrback(logging.err
-                ).addBoth(lambda result: self.semaphore.release())
-
-        d.addCallback(lambda result: self.prompt())
+        logging.msg(
+            'Running, doing at most %d concurrent operations' % (
+                self.options['concurrent'],),
+            verbosity=3)
+        d = util.parallel(
+            self.options.args, self.options['concurrent'], self._processOne)
+        d.addErrback(logging.err)
+        d.addBoth(lambda ignored: reactor.stop())
+        return d

=== removed file 'renamer/env.py'
--- renamer/env.py	2009-05-04 12:11:48 +0000
+++ renamer/env.py	1970-01-01 00:00:00 +0000
@@ -1,311 +0,0 @@
-import codecs, os, shlex
-
-from twisted.internet.defer import maybeDeferred, succeed
-from twisted.python.filepath import FilePath
-
-import renamer
-from renamer import logging
-from renamer.errors import PluginError, StackError, EnvironmentError
-from renamer.plugin import getGlobalPlugins, getPlugin
-
-
-class EnvironmentMode(object):
-    """
-    Environment mode settings.
-
-    @type dryrun: C{bool}
-    @ivar dryrun: Perform a dry run, meaning that no changes, such as file 
-        renames, are persisted
-
-    @type move: C{bool}
-    @ivar move: Enable file moving
-    """
-    def __init__(self, dryrun, move):
-        self.dryrun = dryrun
-        self.move = move
-
-
-class Environment(object):
-    """
-    Renamer script environment.
-
-    @type mode: L{EnvironmentMode}
-
-    @type verbosity: C{int}
-    @ivar verbosity: Verbosity level::
-
-        0 - Quiet
-
-        1 - Normal
-
-        2 - Verbose
-
-    @type stack: L{Stack}
-
-    @type _plugins: C{dict} mapping C{str} to C{dict} mapping C{str} to C{callable}
-    @ivar _plugins: Mapping of C{pluginName} to a mapping of C{commandName} to commands
-    """
-    def __init__(self, args, mode, verbosity):
-        self.mode = mode
-        self.verbosity = verbosity
-
-        self.stack = Stack()
-        self._plugins = {}
-
-        if self.isDryRun:
-            logging.msg('Performing a dry-run.', verbosity=2)
-
-        if self.isMoveEnabled:
-            logging.msg('Moving is enabled.', verbosity=2)
-
-        for p in getGlobalPlugins():
-            self._loadPlugin(p)
-
-        for arg in args:
-            self.stack.push(arg)
-
-    @property
-    def isDryRun(self):
-        return self.mode.dryrun
-
-    @property
-    def isMoveEnabled(self):
-        return self.mode.move
-
-    def openPluginFile(self, plugin, filename):
-        """
-        Open a user-provided file for a plugin.
-
-        @rtype: C{file} or C{None}
-        @return: File object or C{None} if no such file exists, or C{plugin}
-            is a global plugin
-        """
-        if plugin.name is not None:
-            path = FilePath(os.path.expanduser('~/.renamer')).child(plugin.name).child(filename)
-            if path.exists():
-                return path.open()
-        return None
-
-    def getScriptPaths(self):
-        """
-        Retrieve valid script directories.
-
-        @rtype: C{iterable} of C{FilePath} instances
-        """
-        path = FilePath(os.path.expanduser('~/.renamer/scripts'))
-        if path.exists():
-            yield path
-
-        path = FilePath(renamer.__file__).parent().sibling('scripts')
-        if path.exists():
-            yield path
-
-    def openScript(self, filename):
-        """
-        Attempt to open a script file.
-
-        The filename is tried as is, in the context of the current working
-        path, and then the global script paths are tried.
-
-        @raise EnvironmentError: If C{filename} cannot be found
-
-        @rtype: C{file}
-        """
-        def _found(path):
-            logging.msg('Found script: %r.' % (path,), verbosity=2)
-            return codecs.open(path.path, 'rb')
-
-        def _getPaths():
-            yield FilePath(filename)
-            for path in self.getScriptPaths():
-                yield path.child(filename)
-
-        for path in _getPaths():
-            if path.exists():
-                return _found(path)
-
-        raise EnvironmentError('No script named %r.' % (filename,))
-
-    def runScript(self, filename):
-        """
-        Execute a script file.
-        """
-        fd = self.openScript(filename)
-
-        logging.msg('Running script...', verbosity=2)
-
-        def _runLine(result, line):
-            def maybeVerbose(result):
-                if self.verbosity > 2:
-                    logging.msg('rn> ' + line)
-                    return self.execute('stack')
-            return self.execute(line).addCallback(maybeVerbose)
-
-        d = succeed(None)
-        for line in fd:
-            if not line.strip() or line.startswith(u'#'):
-                continue
-            d.addCallback(_runLine, line)
-
-        return d
-
-    def _getCommands(self, plugin):
-        """
-        Enumerate plugin commands.
-        """
-        for name in dir(plugin):
-            attr = getattr(plugin, name, None)
-            if getattr(attr, 'command', False):
-                yield name, attr
-
-    def _loadPlugin(self, pluginType):
-        """
-        Create an instance of C{pluginType} and map its commands.
-        """
-        p = pluginType(env=self)
-        pluginName = p.name or None
-
-        commands = self._plugins.setdefault(pluginName, {})
-        for name, cmd in self._getCommands(p):
-            commands[name] = cmd
-
-    def load(self, pluginName):
-        """
-        Load a plugin by name.
-        """
-        self._loadPlugin(getPlugin(pluginName))
-
-    def _resolveCommand(self, pluginName, name):
-        """
-        Resolve a plugin command by name.
-        """
-        commands = self._plugins.get(pluginName)
-        if commands is None:
-            raise PluginError('No plugin named %r.' % (pluginName,))
-
-        cmd = commands.get(name)
-        if cmd is None:
-            raise PluginError('No command named %r.' % (name,))
-
-        return cmd
-
-    def resolveCommand(self, name):
-        """
-        Resolve a command by name.
-        """
-        if '.' in name:
-            pluginName, name = name.split('.', 1)
-        else:
-            pluginName = None
-        return self._resolveCommand(pluginName, name)
-
-    def parse(self, line):
-        """
-        Parse input according to shell-like rules.
-
-        @rtype: C{(callable, list)}
-        @return: A 2-tuple containing a command callable and a sequence of
-            arguments
-        """
-        args = shlex.split(line)
-        name = args.pop(0)
-        return self.resolveCommand(name), args
-
-    def execute(self, line):
-        """
-        Execute a line of input.
-
-        @rtype: C{Deferred}
-        """
-        def _execute():
-            fn, args = self.parse(line)
-            n = fn.func_code.co_argcount - 1
-
-            def _normalizeArgs():
-                numArgsOnStack = n - len(args) - 1
-                return self.stack.popArgs(numArgsOnStack) + args
-
-            args = _normalizeArgs()
-
-            for arg in args:
-                self.stack.push(arg)
-
-            self.stack.push(fn)
-            return self.stack.call(n)
-
-        return maybeDeferred(_execute)
-
-
-class Stack(object):
-    def __init__(self):
-        self.stack = []
-
-    def size(self):
-        return len(self.stack)
-
-    def push(self, value):
-        """
-        Push a value on to the top of the stack.
-        """
-        self.stack.insert(0, value)
-
-    def pop(self):
-        """
-        Retrieve the value from the top of the stack.
-        """
-        if self.size() == 0:
-            raise StackError('Popping from an empty stack')
-        return self.stack.pop(0)
-
-    def peek(self):
-        """
-        Retrieve the value from the top of the stack, non-destructively.
-        """
-        return self.stack[0]
-
-    def popArgs(self, numArgs):
-        if self.size() < numArgs:
-            raise StackError('Expecting %d stack arguments but only found %d' % (numArgs, self.size()))
-        return list(reversed([self.pop() for _ in xrange(numArgs)]))
-
-    def call(self, numArgs):
-        """
-        Call the function at the top of the stack.
-
-        The top and C{numArgs} entries are popped from the stack, with the
-        return value from the function being left on top of the stack.
-        """
-        fn = self.pop()
-
-        if numArgs:
-            args = self.popArgs(numArgs)
-        else:
-            args = []
-
-        def pushResult(rv):
-            if rv is not None:
-                self.push(rv)
-
-        return maybeDeferred(fn, *args
-            ).addCallback(pushResult)
-
-    def prettyFormat(self):
-        """
-        Get a human-readable stack visualisation.
-
-        @rtype: C{unicode}
-        """
-        if not self.stack:
-            return '<Empty stack>'
-
-        s = u'-->'
-        for v in self.stack:
-            s += u' %r\n' % (v,)
-            s += '   '
-
-        return s.rstrip(u' ')
-
-    def __repr__(self):
-        return '<%s size=%d>' % (
-            type(self).__name__,
-            self.size())

=== modified file 'renamer/errors.py'
--- renamer/errors.py	2009-04-23 12:24:47 +0000
+++ renamer/errors.py	2010-10-10 11:27:40 +0000
@@ -1,16 +1,11 @@
-class StackError(RuntimeError):
-    """
-    An error occured while attempting to manipulate the stack.
-    """
-
-
 class PluginError(RuntimeError):
     """
     An error that has something to do with plugins.
     """
 
 
-class EnvironmentError(RuntimeError):
+
+class DifferentLogicalDevices(RuntimeError):
     """
-    Attempting to do something in the environment failed.
+    An attempt to move a file to a different logical device was made.
     """

=== modified file 'renamer/irenamer.py'
--- renamer/irenamer.py	2009-05-03 19:37:09 +0000
+++ renamer/irenamer.py	2010-10-10 11:27:40 +0000
@@ -1,7 +1,32 @@
 from zope.interface import Interface, Attribute
 
 
-class IRenamerPlugin(Interface):
+
+class IRenamerCommand(Interface):
+    """
+    Renamer command.
+    """
     name = Attribute("""
-    Plugin name or C{None} to indicate a global plugin.
-    """)
+    Command name.
+    """)
+
+
+    description = Attribute("""
+    Brief description of the command.
+    """)
+
+
+    defaultNameFormat = Attribute("""
+    String template for the default name format to use if one is not supplied
+    to Renamer.
+    """)
+
+
+    def processArgument(argument):
+        """
+        Process an argument.
+
+        @rtype:  C{dict} mapping C{unicode} to C{unicode}
+        @return: Mapping of keys to values to substitute info the name
+            template.
+        """

=== modified file 'renamer/logging.py'
--- renamer/logging.py	2009-05-03 19:37:09 +0000
+++ renamer/logging.py	2010-10-10 11:27:40 +0000
@@ -3,22 +3,19 @@
 from twisted.python import log
 
 
+
 class RenamerObserver(object):
     """
-    Twisted event log observer.
+    Twisted event log observer for Renamer.
     """
     def __init__(self, verbosity):
         self.verbosity = verbosity
 
-    def start(self):
-        log.addObserver(self.emit)
-
-    def stop(self):
-        log.removeObserver(self.emit)
 
     def _formatEventMessage(self, message):
         return ' '.join(str(m) for m in message) + '\n'
 
+
     def _emitError(self, eventDict):
         if 'failure' in eventDict:
             text = eventDict['failure'].getTraceback()
@@ -27,6 +24,7 @@
         sys.stderr.write(text)
         sys.stderr.flush()
 
+
     def emit(self, eventDict):
         if eventDict['isError']:
             self._emitError(eventDict)
@@ -34,11 +32,18 @@
             if eventDict.get('source') == 'renamer':
                 verbosity = eventDict.get('verbosity', 1)
                 if self.verbosity >= verbosity:
-                    sys.stdout.write(self._formatEventMessage(eventDict['message']))
+                    leader = '-' * (verbosity - 1)
+                    if leader:
+                        leader += ' '
+                    sys.stdout.write(leader +
+                        self._formatEventMessage(eventDict['message']))
                     sys.stdout.flush()
 
 
+
 def msg(message, **kw):
     log.msg(message, source='renamer', **kw)
 
+
+
 err = log.err

=== modified file 'renamer/main.py'
--- renamer/main.py	2009-04-29 22:26:05 +0000
+++ renamer/main.py	2010-10-10 11:27:40 +0000
@@ -1,3 +1,4 @@
+from twisted.python import log
 from twisted.internet import reactor
 
 from renamer import application
@@ -9,10 +10,8 @@
     options.parseOptions()
 
     obs = RenamerObserver(options['verbosity'])
-    obs.start()
+    log.startLoggingWithObserver(obs.emit, setStdout=False)
 
     r = application.Renamer(options)
     reactor.callWhenRunning(r.run)
     reactor.run()
-
-    obs.stop()

=== modified file 'renamer/plugin.py'
--- renamer/plugin.py	2010-07-19 17:42:22 +0000
+++ renamer/plugin.py	2010-10-10 11:27:40 +0000
@@ -1,91 +1,66 @@
+import sys
+from zope.interface import noLongerProvides
+
 from twisted import plugin
+from twisted.python import usage
 
 from renamer import plugins
-from renamer.errors import PluginError
-from renamer.irenamer import IRenamerPlugin
-
-
-def command(func):
-    """
-    Decorate a function as a Renamer plugin command.
-    """
-    func.command = True
-    return func
+from renamer.irenamer import IRenamerCommand
+from renamer.util import InterfaceProvidingMetaclass
+
 
 
 def getPlugins():
     """
     Get all available Renamer plugins.
     """
-    return plugin.getPlugins(IRenamerPlugin, plugins)
-
-
-def getPlugin(name):
-    """
-    Get a plugin by name.
-
-    @raise PluginError: If no plugin is named C{name}
-    """
-    for p in getPlugins():
-        if p.name == name:
-            return p
-
-    raise PluginError('No plugin named %r.' % (name,))
-
-
-def getGlobalPlugins():
-    """
-    Get all available global plugins.
-    """
-    for p in getPlugins():
-        if p.name is None:
-            yield p
-
-
-class Plugin(object):
-    """
-    Mixin for Renamer plugins.
-
-    @type env: L{Environment}
-
-    @type config: C{dict}
-    @param config: Plugin-specific parameters
-    """
-    def __init__(self, env, **kw):
-        super(Plugin, self).__init__(**kw)
-        self.env = env
-        self.config = self._readConfig()
-
-    def _readConfig(self):
-        """
-        Read a user-provided plugin configuration.
-
-        The configuration is can be found in C{~/.renamer/plugin_name/config}.
-
-        @rtype: C{dict}
-        """
-        fd = self.openFile('config')
-        config = {}
-        if fd is not None:
-            for line in fd:
-                if not line.strip():
-                    continue
-                key, value = line.strip().split('=', 1)
-                config[key] = value
-
-        return config
-
-    def openFile(self, filename):
-        """
-        Open a user-provided file.
-
-        Plugin files are found in C{~/.renamer/plugin_name/}.
-        """
-        return self.env.openPluginFile(self, filename)
-
-    @command
-    def confvar(self, name, default):
-        """
-        Get a config variable.
-        """
-        return self.config.get(name, default)
+    return plugin.getPlugins(IRenamerCommand, plugins)
+
+
+
+class RenamerSubCommandMixin(object):
+    """
+    Mixin for Renamer commands.
+    """
+    def decodeCommandLine(self, cmdline):
+        """
+        Turn a byte string from the command line into a unicode string.
+        """
+        codec = getattr(sys.stdin, 'encoding', None) or sys.getdefaultencoding()
+        return unicode(cmdline, codec)
+
+
+
+class RenamerSubCommand(usage.Options, RenamerSubCommandMixin):
+    """
+    Sub-level Renamer command.
+    """
+
+
+
+class RenamerCommandMeta(InterfaceProvidingMetaclass):
+    providedInterfaces = [plugin.IPlugin, IRenamerCommand]
+
+
+
+class RenamerCommand(usage.Options, RenamerSubCommandMixin):
+    """
+    Top-level Renamer command.
+
+    These commands will display in the main help listing.
+    """
+    __metaclass__ = RenamerCommandMeta
+
+    defaultPrefixTemplate = None
+    defaultNameTemplate = None
+
+
+    def parseArgs(self, *args):
+        self.parent.parseArgs(*args)
+
+
+    def postOptions(self):
+        self.parent.command = self
+
+noLongerProvides(RenamerCommand, plugin.IPlugin)
+noLongerProvides(RenamerCommand, IRenamerCommand)

=== modified file 'renamer/plugins/audio.py'
--- renamer/plugins/audio.py	2009-05-10 19:22:32 +0000
+++ renamer/plugins/audio.py	2010-10-10 11:27:40 +0000
@@ -1,28 +1,50 @@
+import string
+from functools import partial
+
 try:
     import mutagen
+    mutagen # Ssssh, Pyflakes.
 except ImportError:
     mutagen = None
 
-from zope.interface import classProvides
-
-from twisted.plugin import IPlugin
-
-from renamer.irenamer import IRenamerPlugin
-from renamer.plugin import Plugin, command
+from renamer import logging
+from renamer.plugin import RenamerCommand
 from renamer.errors import PluginError
 
 
-class Audio(Plugin):
-    classProvides(IPlugin, IRenamerPlugin)
 
+class Audio(RenamerCommand):
     name = 'audio'
 
-    def __init__(self, **kw):
+
+    description = 'Rename audio files with their metadata.'
+
+
+    longdesc = """
+    Rename audio files based on their own metadata.
+
+    Available placeholders for templates are:
+
+    artist, album, title, date, tracknumber
+    """
+
+
+    defaultPrefixTemplate = string.Template(
+        '${artist}/${album} (${date})')
+
+
+    defaultNameTemplate = string.Template(
+        '${tracknumber}. ${title}')
+
+
+    def postOptions(self):
         if mutagen is None:
-            raise PluginError('"mutagen" package is required for this plugin')
-        super(Audio, self).__init__(**kw)
+            raise PluginError(
+                'The "mutagen" package is required for this command')
+        super(Audio, self).postOptions()
         self._metadataCache = {}
 
+
     def _getMetadata(self, filename):
         """
         Get file metadata.
@@ -31,21 +53,22 @@
             self._metadataCache[filename] = mutagen.File(filename)
         return self._metadataCache[filename]
 
-    def _getTag(self, filename, tagNames, default=None):
+
+    def getTag(self, path, tagNames, default=u'UNKNOWN'):
         """
         Get a metadata field by name.
 
-        @type filename: C{str} or C{unicode}
+        @type filename: L{twisted.python.filepath.FilePath}
 
-        @type tagNames: C{str} or C{unicode}
+        @type tagNames: C{list} of C{unicode}
         @param tagNames: A C{|} separated list of tag names to attempt when
             retrieving a value, the first successful result is returned
 
         @return: Tag value as C{unicode} or C{default}
         """
-        md = self._getMetadata(filename)
-
-        tagNames = tagNames.split('|')
+        logging.msg('Getting metadata for %r from "%s"' % (tagNames, path.path),
+                    verbosity=4)
+        md = self._getMetadata(path.path)
         for tagName in tagNames:
             try:
                 return unicode(md[tagName][0])
@@ -54,29 +77,19 @@
 
         return default
 
-    @command
-    def gettags(self, filename, tagNames, default):
-        """
-        Retrieve a list of tag values.
-
-        Multiple tags may be specified by delimiting the names with ",".
-        Alternate tag names for a particular tag may be delimited with "|".
-
-        For example: "title|TIT2,album" would retrieve a tag named "title"
-        (or "TIT2" if "title" didn't exist) and then a tag named "album".
-        """
-        return [self._getTag(filename, tagName.strip(), default)
-                for tagName in tagNames.split(',')]
-
-    _extensions = {
-        'audio/x-flac': '.flac'}
-
-    @command
-    def extension(self, filename):
-        md = self._getMetadata(filename)
-        for mimeType in md.mime:
-            ext = self._extensions.get(mimeType)
-            if ext is not None:
-                return ext
-
-        return '.' + md.mime[0].split('/', 1)[1]
+    def _saneTracknumber(self, tracknumber):
+        if u'/' in tracknumber:
+            tracknumber = tracknumber.split(u'/')[0]
+        return int(tracknumber)
+
+
+    # IRenamerCommand
+
+    def processArgument(self, arg):
+        T = partial(self.getTag, arg)
+        return dict(
+            artist=T([u'artist', u'TPE1']),
+            album=T([u'album', u'TALB']),
+            title=T([u'title', u'TIT2']),
+            date=T([u'date', u'year', u'TDRC']),
+            tracknumber=self._saneTracknumber(T([u'tracknumber', u'TRCK'])))

=== removed file 'renamer/plugins/common.py'
--- renamer/plugins/common.py	2009-05-07 11:50:08 +0000
+++ renamer/plugins/common.py	1970-01-01 00:00:00 +0000
@@ -1,307 +0,0 @@
-import os, re, textwrap
-
-from zope.interface import classProvides
-
-from twisted.plugin import IPlugin
-
-from renamer import logging
-from renamer.irenamer import IRenamerPlugin
-from renamer.plugin import Plugin, command
-from renamer.util import Replacement, Replacer, padIterable
-
-
-class Common(Plugin):
-    classProvides(IPlugin, IRenamerPlugin)
-
-    name = None
-
-    def __init__(self, **kw):
-        super(Common, self).__init__(**kw)
-        self.vars = {}
-
-    @command
-    def push(self, value):
-        """
-        Push an argument onto the stack.
-
-        Parameters prefixed with a `$` are expanded from the variables
-        dictionary (as stored by the `var` command.) `$$` produces a literal
-        `$`.
-        """
-        if value.startswith('$'):
-            if value.startswith('$$'):
-                return value[1:]
-            else:
-                return self.vars[value[1:]]
-        return value
-
-    @command
-    def pushdefault(self, value, default):
-        """
-        Push an argument onto the stack, optionally using a default.
-
-        Primarily useful for when attempting to use `$` expansion might
-        fail.
-        """
-        try:
-            return self.push(value)
-        except KeyError:
-            return default
-
-    @command
-    def expanditer(self, iterable):
-        """
-        Expand an iterable.
-
-        Each element of an iterable is pushed individually onto the stack.
-
-        e.g::
-            rn> push "abc"
-            rn> expanditer
-            rn> stack
-            --> 'a'
-                'b'
-                'c'
-        """
-        iterable = list(iter(iterable))
-        for e in reversed(iterable):
-            self.env.stack.push(e)
-
-    @command
-    def paditer(self, iterable, padding, count):
-        """
-        Pad an iterable on the stack with "padding" to "count" elements.
-        """
-        return list(padIterable(iter(iterable), padding, int(count)))
-
-    @command
-    def pop(self):
-        """
-        Pop a value from the top of the stack.
-        """
-        self.env.stack.pop()
-
-    @command
-    def dup(self):
-        """
-        Duplicate the value at the top of the stack.
-        """
-        return self.env.stack.peek()
-
-    @command
-    def duplistn(self, seq, index):
-        """
-        Duplicate the value at a given index in a sequence.
-        """
-        index = int(index)
-        self.env.stack.push(seq)
-        return seq[index]
-
-    @command
-    def split(self, s, delim):
-        """
-        Split a string on a delimiter.
-        """
-        return s.split(delim)
-
-    @command
-    def splitn(self, s, delim, n):
-        """
-        Split a string on a delimiter up to `n` times.
-        """
-        return s.split(delim, int(n))
-
-    @command
-    def rsplitn(self, s, delim, n):
-        """
-        Split a string in reverse on a delimier up to `n` times.
-        """
-        return s.rsplit(delim, int(n))
-
-    @command
-    def join(self, it, delim):
-        """
-        Join an iterable with a delimiter.
-        """
-        return delim.join(it)
-
-    @command
-    def strip(self, s, chars):
-        """
-        Strip a string of characters.
-        """
-        return s.strip(chars)
-
-    @command
-    def title(self, s):
-        """
-        Title case a string.
-        """
-        return s.title()
-
-    @command
-    def lower(self, s):
-        """
-        Lower case a string.
-        """
-        return s.lower()
-
-    @command
-    def int(self, s):
-        """
-        Convert a string to an integer.
-        """
-        return int(s)
-
-    @command
-    def load(self, name):
-        """
-        Load a plugin by name.
-        """
-        self.env.load(name)
-
-    @command
-    def stack(self):
-        """
-        Pretty-print the current stack.
-        """
-        print self.env.stack.prettyFormat()
-
-    @command
-    def commands(self):
-        """
-        List all available commands.
-        """
-        lines = []
-        for pluginName, commands in sorted(self.env._plugins.iteritems()):
-            if commands:
-                if pluginName is None:
-                    pluginName = 'Global:'
-                else:
-                    pluginName = '%s:' % (pluginName,)
-                print pluginName
-                print '   ', ', '.join(sorted(commands.iterkeys()))
-
-    @command
-    def help(self, name):
-        """
-        Retrieve help for a given command.
-        """
-        cmd = self.env.resolveCommand(name)
-        if cmd.__doc__:
-            code = cmd.im_func.func_code
-            argnames = code.co_varnames[1:code.co_argcount]
-            doc = '%s(%s)%s%s' % (cmd.im_func.func_name,
-                                  ', '.join(argnames),
-                                  os.linesep,
-                                  textwrap.dedent(cmd.__doc__.strip()))
-        else:
-            doc = 'No help available.'
-
-        print doc
-
-    @command
-    def inc(self, value):
-        """
-        Increment a numerical value.
-        """
-        return value + 1
-
-    @command
-    def dec(self, value):
-        """
-        Decrement a numerical value.
-        """
-        return value - 1
-
-    # XXX: this sucks
-    @command
-    def camel_case_into_sentence(self, s):
-        """
-        Convert a camel-case string into a sentence.
-
-        e.g::
-            rn> push "LikeThisOne"
-            rn> camel_case_into_sentence
-            rn> stack
-            --> 'Like This One'
-        """
-        return re.sub(r'(?<![\s-])([A-Z\(])', r' \1', s).strip()
-
-    def _setvar(self, name, value):
-        self.vars[name] = value
-
-    @command
-    def regex(self, s, r):
-        m = re.match(r, s)
-        if m is not None:
-            for key, value in m.groupdict().iteritems():
-                self._setvar(key, value)
-            return list(m.groups())
-
-    @command
-    def var(self, value, name):
-        """
-        Store a variable.
-        """
-        self._setvar(name, value)
-
-    @command
-    def envvar(self, name, default):
-        """
-        Get an environment variable.
-        """
-        return os.environ.get(name, default)
-
-    @command
-    def format(self, fmt):
-        """
-        Perform string interpolation with the stored variable dictionary.
-        """
-        return fmt % self.vars
-
-    @command
-    def quit(self):
-        """
-        Exit the environment.
-        """
-        raise EOFError()
-
-
-class OS(Plugin):
-    classProvides(IPlugin, IRenamerPlugin)
-
-    name = 'os'
-
-    def __init__(self, **kw):
-        super(OS, self).__init__(**kw)
-        self.repl = Replacement.fromIterable(self.openFile('replace'))
-        self.repl.add(Replacer(r'[*<>/]', ''))
-
-    @command
-    def move(self, src, dstDir):
-        """
-        Move a file to a directory.
-        """
-        dstPath = os.path.join(dstDir, src)
-        if self.env.isMoveEnabled:
-            logging.msg('Move: %s ->\n %s' % (src, dstPath))
-            if not self.env.isDryRun:
-                if not os.path.exists(dstDir):
-                    os.makedirs(dstDir)
-                os.rename(src, dstPath)
-
-        return dstPath
-
-    @command
-    def rename(self, src, dst):
-        """
-        Rename a file.
-        """
-        dst = self.repl.replace(dst)
-
-        logging.msg('Rename: %s ->\n  %s' % (src, dst))
-        if not self.env.isDryRun:
-            os.rename(src, dst)
-
-        return dst

=== modified file 'renamer/plugins/tv.py'
--- renamer/plugins/tv.py	2010-04-29 13:12:48 +0000
+++ renamer/plugins/tv.py	2010-10-10 11:27:40 +0000
@@ -1,49 +1,70 @@
+import string
 import urllib
 
-from zope.interface import classProvides
-
-from twisted.plugin import IPlugin
 from twisted.web.client import getPage
 
-from renamer.irenamer import IRenamerPlugin
-from renamer.plugin import Plugin, command
-
 try:
     import pyparsing
-    from pyparsing import (alphanums, nums, Word, Literal, ParseException, SkipTo,
-        FollowedBy, ZeroOrMore, Combine, NotAny, Optional, StringEnd)
+    from pyparsing import (
+        alphanums, nums, Word, Literal, ParseException, SkipTo, FollowedBy,
+        ZeroOrMore, Combine, NotAny, Optional, StringEnd)
+    pyparsing # Ssssh, Pyflakes.
 except ImportError:
     pyparsing = None
 
+from renamer import logging
+from renamer.plugin import RenamerCommand
 from renamer.errors import PluginError
-from renamer.util import Replacement, ConditionalReplacer
-
-
-class TV(Plugin):
-    classProvides(IPlugin, IRenamerPlugin)
-
-    name = 'tv'
-
-    def __init__(self, **kw):
-        if pyparsing is None:
-            raise PluginError('"pyparsing" package is required for this plugin')
-        super(TV, self).__init__(**kw)
-        self.filename = self._createParser()
-        self.repl = {
-            'show': Replacement.fromIterable(self.openFile('shownames')),
-            'ep':   Replacement.fromIterable(self.openFile('epnames'), ConditionalReplacer)}
+
+
+
+class TVRage(RenamerCommand):
+    name = 'tvrage'
+
+
+    description = 'Rename TV episodes with TV Rage metadata.'
+
+
+    longdesc = """
+    Extract TV episode information from filenames and rename them based on the
+    correct information from TV Rage <http://tvrage.com/>.
+
+    Available placeholders for templates are:
+
+    series, season, padded_season, episode, padded_episode, title
+    """
+
+
+    defaultNameTemplate = string.Template(
+        '$series [${season}x${padded_episode}] - $title')
+
+
+    def postOptions(self):
+        super(TVRage, self).postOptions()
+        self.filenameParser = self._createParser()
+
 
     def _createParser(self):
         """
         Create the filename parser.
         """
+        if pyparsing is None:
+            raise PluginError(
+                'The "pyparsing" package is required for this command')
+
         def L(value):
             return Literal(value).suppress()
 
         number = Word(nums)
         digit = Word(nums, exact=1)
 
-        separator = Literal('_-_') | Literal(' - ') | Literal('.-.') | Literal('-') | Literal('.') | Literal('_') | Literal(' ')
+        separator = ( Literal('_-_')
+                    | Literal(' - ')
+                    | Literal('.-.')
+                    | Literal('-')
+                    | Literal('.')
+                    | Literal('_')
+                    | Literal(' '))
         separator = separator.suppress().leaveWhitespace()
 
         season = number.setResultsName('season')
@@ -56,49 +77,79 @@
                   | L('S') + season + L('E') + epnum
                   | L('s') + season + L('e') + epnum
                   | exact_season + exact_epnum
-                  | short_season + exact_epnum
-                  )
+                  | short_season + exact_epnum)
 
         series_word = Word(alphanums)
-        series = ZeroOrMore(series_word + separator + NotAny(episode + separator)) + series_word
+        series = ZeroOrMore(
+            series_word + separator + NotAny(episode + separator)) + series_word
         series = Combine(series, joinString=' ').setResultsName('series_name')
 
         extension = '.' + Word(alphanums).setResultsName('ext') + StringEnd()
 
         title = SkipTo(FollowedBy(extension))
 
-        return series + separator + episode + Optional(separator + title) + extension
-
-    @command
-    def find_parts(self, src):
+        return (series + separator + episode + Optional(separator + title) +
+                extension)
+
+
+    def buildMapping(self, (seriesName, season, episode, episodeName)):
+        return dict(
+            series=seriesName,
+            season=season,
+            padded_season=u'%02d' % (season,),
+            episode=episode,
+            padded_episode=u'%02d' % (episode,),
+            title=episodeName)
+
+
+    def extractParts(self, filename):
         """
         Get TV episode information from a filename.
         """
         try:
-            parse = self.filename.parseString(src)
+            parse = self.filenameParser.parseString(filename)
         except ParseException, e:
-            raise PluginError('No patterns could be found in %r (%r)' % (src, e))
+            raise PluginError(
+                'No patterns could be found in "%s" (%r)' % (filename, e))
         else:
-            return parse.series_name, parse.season, parse.ep, parse.ext
-
-    @command
-    def tvrage(self, key, showName):
-        """
-        Look up TV episode information on TV Rage.
-        """
-        qs = urllib.urlencode([('show', showName), ('ep', key)])
+            parts = parse.series_name, parse.season, parse.ep, parse.ext
+            logging.msg('Found parts in "%s": %r' % (filename, parts),
+                        verbosity=4)
+            return parts
+
+
+    def extractMetadata(self, pageData):
+        """
+        Extract TV episode metadata from a TV Rage response.
+        """
+        data = {}
+        for line in pageData.splitlines():
+            key, value = line.strip().split('@', 1)
+            data[key] = value.split('^')
+
+        series = data['Show Name'][0]
+        season, episode = map(int, data['Episode Info'][0].split('x'))
+        title = data['Episode Info'][1]
+        return series, season, episode, title
+
+
+    def lookupMetadata(self, seriesName, season, episode, fetcher=getPage):
+        """
+        Look up TV episode metadata on TV Rage.
+        """
+        ep = '%dx%02d' % (int(season), int(episode))
+        qs = urllib.urlencode({'show': seriesName, 'ep': ep})
         url = 'http://services.tvrage.com/tools/quickinfo.php?%s' % (qs,)
-
-        def getParams(page):
-            data = {}
-            for line in page.splitlines():
-                key, value = line.strip().split('@', 1)
-                data[key] = value.split('^')
-
-            showName = self.repl['show'].replace(data['Show Name'][0])
-            season, epNumber = map(int, data['Episode Info'][0].split('x'))
-            epName = self.repl['ep'].replace(data['Episode Info'][1], showName)
-
-            return showName, season, epNumber, epName
-
-        return getPage(url).addCallback(getParams)
+        logging.msg('Looking up TV Rage metadata at %s' % (url,),
+                    verbosity=4)
+        return fetcher(url).addCallback(self.extractMetadata)
+
+
+    # IRenamerCommand
+
+    def processArgument(self, arg):
+        # XXX: why does our pattern care about the extension?
+        seriesName, season, episode, ext = self.extractParts(arg.basename())
+        d = self.lookupMetadata(seriesName, season, episode)
+        d.addCallback(self.buildMapping)
+        return d

=== added directory 'renamer/test/data'
=== added file 'renamer/test/data/tvrage'
--- renamer/test/data/tvrage	1970-01-01 00:00:00 +0000
+++ renamer/test/data/tvrage	2010-10-10 11:27:40 +0000
@@ -0,0 +1,19 @@
+Show ID@7926
+Show Name@Dexter
+Show URL@http://www.tvrage.com/Dexter
+Premiered@2006
+Started@Oct/01/2006
+Ended@
+Episode Info@01x02^Crocodile^08/Oct/2006
+Episode URL@http://www.tvrage.com/Dexter/episodes/408410
+Latest Episode@05x01^My Bad^Sep/26/2010
+Next Episode@05x02^Hello, Bandit^Oct/03/2010
+RFC3339@2010-10-03T21:00:00-4:00
+GMT+0 NODST@1286146800
+Country@USA
+Status@Returning Series
+Classification@Scripted
+Genres@Crime | Drama
+Network@Showtime
+Airtime@Sunday at 09:00 pm
+Runtime@60

=== removed file 'renamer/test/test_env.py'
--- renamer/test/test_env.py	2009-04-27 12:40:40 +0000
+++ renamer/test/test_env.py	1970-01-01 00:00:00 +0000
@@ -1,53 +0,0 @@
-from twisted.trial.unittest import TestCase
-
-from renamer.errors import StackError
-from renamer.env import Stack
-
-
-class StackTests(TestCase):
-    def makeStack(self):
-        stack = Stack()
-        for arg in [u'arg1', u'arg2', u'arg3']:
-            stack.push(arg)
-
-        return stack
-
-    def test_pushPopPeek(self):
-        """
-        Pushing, popping and peeking for the stack behave as intended.
-        """
-        stack = Stack()
-
-        self.assertRaises(StackError, stack.pop)
-
-        stack.push(1)
-        self.assertEqual(stack.pop(), 1)
-
-        stack.push(u'a')
-        stack.push(u'b')
-        self.assertEqual(stack.pop(), u'b')
-        self.assertEqual(stack.pop(), u'a')
-
-        stack.push(u'c')
-        self.assertEqual(stack.peek(), u'c')
-        self.assertEqual(stack.size(), 1)
-
-    def test_popArgs(self):
-        """
-        Values popped for use as function arguments appear in the correct order.
-        """
-        self.assertEqual(self.makeStack().popArgs(1), [u'arg3'])
-        self.assertEqual(self.makeStack().popArgs(2), [u'arg2', u'arg3'])
-        self.assertEqual(self.makeStack().popArgs(3), [u'arg1', u'arg2', u'arg3'])
-
-    def test_prettyFormat(self):
-        """
-        Pretty-formatting the stack results in correctly formatted output.
-        """
-        stack = self.makeStack()
-        format = u'''\
---> u'arg3'
-    u'arg2'
-    u'arg1'
-'''
-        self.assertEqual(stack.prettyFormat(), format)

=== added file 'renamer/test/test_plugin.py'
--- renamer/test/test_plugin.py	1970-01-01 00:00:00 +0000
+++ renamer/test/test_plugin.py	2010-10-10 11:27:40 +0000
@@ -0,0 +1,34 @@
+import sys
+
+from twisted.trial.unittest import TestCase
+
+from renamer import plugin
+
+
+
+class RenamerCommandTests(TestCase):
+    """
+    Tests for Renamer command mixins in L{renamer.plugin}.
+    """
+    def test_decodeCommandLine(self):
+        """
+        L{renamer.plugin.RenamerSubCommandMixin.decodeCommandLine} turns a byte
+        string from the command line into a unicode string.
+        """
+        decodeCommandLine = plugin.RenamerSubCommandMixin().decodeCommandLine
+
+        class MockFile(object):
+            pass
+
+        mf = MockFile()
+        self.patch(sys, 'stdin', mf)
+
+        mf.encoding = 'utf-8'
+        self.assertEquals(
+            decodeCommandLine(u'\u263a'.encode('utf-8')),
+            u'\u263a')
+
+        mf.encoding = None
+        self.assertEquals(
+            decodeCommandLine(u'hello'.encode(sys.getdefaultencoding())),
+            u'hello')

=== renamed file 'renamer/test/test_plugins.py' => 'renamer/test/test_tvrage.py'
--- renamer/test/test_plugins.py	2009-05-03 19:37:09 +0000
+++ renamer/test/test_tvrage.py	2010-10-10 11:27:40 +0000
@@ -1,9 +1,26 @@
+import cgi
+import urllib
+
+from twisted.internet.defer import succeed
+from twisted.python.filepath import FilePath
 from twisted.trial.unittest import TestCase
 
-from renamer.env import Environment, EnvironmentMode
-from renamer.plugins.tv import TV
-
-class TVTests(TestCase):
+from renamer import errors
+from renamer.plugins import tv
+
+
+
+class DummyPluginParent(object):
+    """
+    Dummy plugin parent.
+    """
+
+
+
+class TVRageTests(TestCase):
+    """
+    Tests for L{renamer.plugins.tv.TVRage}.
+    """
     cases = [
         ('Profiler - S01E01 - Insight.avi', 'Profiler', '01', '01', 'avi'),
         ('Heroes [1x01] - Genesis.avi', 'Heroes', '1', '01', 'avi'),
@@ -20,21 +37,81 @@
         ('Xena_4x02_Adventures In The Sin Trade - Part 2.avi', 'Xena', '4', '02', 'avi'),
         ('Sliders 501 - The Unstuck Man.avi', 'Sliders', '5', '01', 'avi'),
         ('buffy.2x03.dvdrip.xvid-tns.avi', 'buffy', '2', '03', 'avi'),
-        ('the.4400.1x05.avi', 'the 4400', '1', '05', 'avi'),
-        ('ReGenesis - 1x13.avi', 'ReGenesis', '1', '13', 'avi'),
-        ]
+        # XXX: This is broken and probably has been for a long time, it would
+        # be nice if it worked again.
+        #('the.4400.1x05.avi', 'the 4400', '1', '05', 'avi'),
+        # This should work, but doesn't.
+        #('flash.gordon.2007.s01e02.dvdrip.xvid-reward.avi', 'flash gordon 2007', '01', '02', 'avi'),
+        ('ReGenesis - 1x13.avi', 'ReGenesis', '1', '13', 'avi')]
+
 
     def setUp(self):
-        mode = EnvironmentMode(dryrun=True,
-                               move=False)
-        self.env = Environment(args=[],
-                               mode=mode,
-                               verbosity=0)
-        self.plugin = TV(env=self.env)
-
-    def test_findParts(self):
+        self.dataPath = FilePath(__file__).sibling('data')
+        self.plugin = tv.TVRage()
+        self.plugin.parent = DummyPluginParent()
+        self.plugin.postOptions()
+
+
+    def fetcher(self, url):
+        """
+        "Fetch" TV rage data.
+        """
+        data = self.dataPath.child('tvrage').open().read()
+        return succeed(data)
+
+
+    def test_extractParts(self):
         """
         Extracting TV show information from filenames works correctly.
         """
         for case in self.cases:
-            self.assertEqual(self.plugin.find_parts(case[0]), case[1:])
+            self.assertEquals(self.plugin.extractParts(case[0]), case[1:])
+
+        self.assertRaises(errors.PluginError,
+            self.plugin.extractParts, 'thiswillnotwork')
+
+
+    def test_missingPyParsing(self):
+        """
+        Attempting to use the TV Rage plugin without PyParsing installed raises
+        a L{renamer.errors.PluginError}.
+        """
+        self.patch(tv, 'pyparsing', None)
+        plugin = tv.TVRage()
+        plugin.parent = DummyPluginParent()
+        e = self.assertRaises(errors.PluginError, plugin.postOptions)
+        self.assertEquals(
+            str(e), 'The "pyparsing" package is required for this command')
+
+
+    def test_extractMetadata(self):
+        """
+        L{renamer.plugins.tv.TVRage.extractMetadata} extracts structured TV
+        episode information from a TV Rage response.
+        """
+        d = self.plugin.lookupMetadata('Dexter', 1, 2, fetcher=self.fetcher)
+
+        @d.addCallback
+        def checkMetadata((series, season, episode, title)):
+            self.assertEquals(series, u'Dexter')
+            self.assertEquals(season, 1)
+            self.assertEquals(episode, 2)
+            self.assertEquals(title, u'Crocodile')
+
+        return d
+
+
+    def test_lookupMetadata(self):
+        """
+        L{renamer.plugins.tv.TVRage.lookupMetadata} requests structured TV
+        episode information from TV Rage.
+        """
+        def fetcher(url):
+            path, query = urllib.splitquery(url)
+            query = cgi.parse_qs(query)
+            self.assertEquals(
+                query,
+                dict(show=['Dexter'], ep=['1x02']))
+            return self.fetcher(url)
+
+        return self.plugin.lookupMetadata('Dexter', 1, 2, fetcher=fetcher)

=== added file 'renamer/test/test_util.py'
--- renamer/test/test_util.py	1970-01-01 00:00:00 +0000
+++ renamer/test/test_util.py	2010-10-10 11:27:40 +0000
@@ -0,0 +1,89 @@
+import errno
+from zope.interface import Interface
+
+from twisted.python.filepath import FilePath
+from twisted.trial.unittest import TestCase
+
+from renamer import errors, util
+
+
+
+class UtilTests(TestCase):
+    """
+    Tests for L{renamer.util}.
+    """
+    def setUp(self):
+        self.path = FilePath(self.mktemp())
+        self.path.makedirs()
+
+
+    def exdev(self, s, d):
+        e = OSError()
+        e.errno = errno.EXDEV
+        raise e
+
+
+    def test_rename(self):
+        """
+        Rename a file, copying it across filesystems if need be.
+        """
+        src = self.path.child('src')
+        src.touch()
+        dst = self.path.child('dst')
+        self.assertTrue(not dst.exists())
+        util.rename(src, dst)
+        self.assertTrue(dst.exists())
+
+
+    def test_renameOneFileSystem(self):
+        """
+        Attempting to rename a file across file system boundaries when
+        C{oneFileSystem} is C{True} results in
+        L{renamer.errors.DifferentLogicalDevices} being raised, assuming the
+        current platform doesn't support cross-linking.
+        """
+        src = self.path.child('src')
+        src.touch()
+        dst = self.path.child('dst')
+        self.assertRaises(
+            errors.DifferentLogicalDevices,
+            util.rename, src, dst, oneFileSystem=True, renamer=self.exdev)
+
+        self.assertTrue(not dst.exists())
+        util.rename(src, dst, oneFileSystem=True)
+        self.assertTrue(dst.exists())
+
+
+
+class IThing(Interface):
+    """
+    Silly test interface.
+    """
+
+
+
+class ThingMeta(util.InterfaceProvidingMetaclass):
+    """
+    Metaclass that C{alsoProvides} IThing.
+    """
+    providedInterfaces = [IThing]
+
+
+
+class Thing(object):
+    """
+    IThing, the silly test interface, providing base class.
+    """
+    __metaclass__ = ThingMeta
+
+
+
+class InterfaceProvidingMetaclassTests(TestCase):
+    """
+    Tests for L{renamer.util.InterfaceProvidingMetaclass}.
+    """
+    def test_providedBy(self):
+        """
+        Interfaces are not provided by subclasses.
+        """
+        self.assertTrue(IThing.providedBy(Thing))

=== modified file 'renamer/util.py'
--- renamer/util.py	2009-05-07 11:50:08 +0000
+++ renamer/util.py	2010-10-10 11:27:40 +0000
@@ -1,158 +1,11 @@
-"""
-Collection of miscellaneous utility functions.
-"""
-import itertools, re
+import errno, os
+from zope.interface import alsoProvides
 
 from twisted.internet.defer import DeferredList
 from twisted.internet.task import Cooperator
 
-
-class ConditionalReplacer(object):
-    """
-    Perform regular-expression substitutions based on a conditional regular-expression.
-
-    @type globalReplace: C{bool}
-    @ivar globalReplace: Flag indicating whether to perform a global replace
-        or not
-
-    @type cond: C{regex}
-    @ivar cond: Conditional compiled regular-expression
-
-    @type regex: C{regex}
-    @ivar regex: Regular-expression to match for substitution
-    """
-    def __init__(self, cond, regex, subst=None, flags=None):
-        """
-        Initialise the replacer.
-
-        @type cond: C{str} or C{unicode}
-        @param cond: Conditional regular-expression to compile
-
-        @type regex: C{str} or C{unicode}
-        @param regex: Regular-expression to match for substitution
-
-        @type subst: C{str} or C{unicode}
-        @param subst: String to use for substitution
-
-        @type flags: C{str}
-        @param flags: Collection of regular-expression flags, the following
-            values are valid::
-
-                i - Ignore case
-
-                g - Global replace
-        """
-        super(ConditionalReplacer, self).__init__()
-
-        if flags is None:
-            flags = ''
-
-        self.globalReplace = 'g' in flags
-
-        reflags = 0
-        if 'i' in flags:
-            reflags |= re.IGNORECASE
-
-        self.cond = re.compile(cond, reflags)
-        self.regex = re.compile(regex, reflags)
-        self.subst = subst or ''
-
-    @classmethod
-    def fromString(cls, s):
-        """
-        Create a replacer from a string.
-
-        Parameters should be separated by a literal tab and are passed
-        directly to the initialiser.
-        """
-        return cls(*s.strip('\r\n').split('\t'))
-
-    def replace(self, input, condInput):
-        """
-        Perform a replacement.
-
-        @type input: C{str} or C{unicode}
-        @param input: Input to perform substitution on
-
-        @type condInput: C{str} or C{unicode}
-        @param condInput: Input to check against C{cond}
-
-        @rtype: C{str} or C{unicode}
-        @return: Substituted result
-        """
-        if self.cond.search(condInput) is None:
-            return input
-        return self.regex.sub(self.subst, input, int(not self.globalReplace))
-
-
-class Replacer(ConditionalReplacer):
-    """
-    Perform regular-expression substitutions.
-    """
-    def __init__(self, regex, subst=None, flags=None):
-        super(Replacer, self).__init__(r'.*', regex, subst, flags)
-
-    def replace(self, input, condInput):
-        return super(Replacer, self).replace(input, input)
-
-
-class Replacement(object):
-    """
-    Perform a series of replacements on input.
-
-    @type replacers: C{list}
-    @ivar replacers: Replacer objects used to transform input
-    """
-    def __init__(self, replacers):
-        """
-        Initialise a Replacer manager.
-
-        @type replacers: C{iterable}
-        @param replacers: Initial set of replacer objects
-        """
-        super(Replacement, self).__init__()
-        self.replacers = list(replacers)
-
-    @classmethod
-    def fromIterable(cls, iterable, replacerType=Replacer):
-        """
-        Create a L{Replacement} instance from an iterable.
-
-        Lines beginning with C{#} are ignored
-
-        @type iterable: C{iterable} of C{str} or C{unicode}
-        @param iterable: Lines to create replacer objects from.
-
-        @type replacerType: C{type}
-        @param replacerType: Replacer object type to create for each line,
-            defaults to L{Replacer}
-
-        @rtype: L{Replacement}
-        """
-        replacers = []
-        if iterable is not None:
-            replacers = [replacerType.fromString(line)
-                         for line in iterable
-                         if line.strip() and not line.startswith('#')]
-        return cls(replacers)
-
-    def add(self, replacer):
-        """
-        Add a new replacer object.
-        """
-        self.replacers.append(replacer)
-
-    def replace(self, input, condInput=None):
-        """
-        Perform a replacement.
-        """
-        if condInput is None:
-            condInput = input
-
-        for r in self.replacers:
-            input = r.replace(input, condInput)
-
-        return input
+from renamer import errors
+
 
 
 def parallel(iterable, count, callable, *a, **kw):
@@ -161,33 +14,62 @@
 
     Any additional arguments or keyword-arguments are passed to C{callable}.
 
-    @type iterable: C{iterable}
-    @param iterable: Values to pass to C{callable}
-
-    @type count: C{int}
-    @param count: Limit of the number of concurrent tasks
-
-    @type callable: C{callable}
-    @param callable: Callable to fire concurrently
-
-    @rtype: C{twisted.internet.defer.Deferred}
-    @return: Results of each call to C{callable}
+    @type  iterable: C{iterable}
+    @param iterable: Values to pass to C{callable}.
+
+    @type  count: C{int}
+    @param count: Limit of the number of concurrent tasks.
+
+    @type  callable: C{callable}
+    @param callable: Callable to fire concurrently.
+
+    @rtype:  L{twisted.internet.defer.Deferred}
     """
     coop = Cooperator()
     work = (callable(elem, *a, **kw) for elem in iterable)
     return DeferredList([coop.coiterate(work) for i in xrange(count)])
 
 
-def padIterable(iterable, padding, count):
-    """
-    Pad C{iterable}, with C{padding}, to C{count} elements.
-
-    Iterables containing more than C{count} elements are clipped to C{count}
-    elements.
-
-    @param iterable: The iterable to iterate.
-    @param padding: Padding object.
-    @param count: The padded length.
-    @return: An iterable.
-    """
-    return itertools.islice(itertools.chain(iterable, itertools.repeat(padding)), count)
+
+def rename(src, dst, oneFileSystem=False, renamer=os.rename):
+    """
+    Rename a file, optionally refusing to do it across file systems.
+
+    @type  src: L{twisted.python.filepath.FilePath}
+    @param src: Source path.
+
+    @type  dst: L{twisted.python.filepath.FilePath}
+    @param dst: Destination path.
+
+    @type  oneFileSystem: C{bool}
+    @param oneFileSystem: Refuse to move a file across file systems?
+
+    @raise renamer.errors.DifferentLogicalDevices: If C{src} and C{dst} reside
+        on different filesystems and cross-linking files is not supported on
+        the current platform.
+    """
+    if oneFileSystem:
+        try:
+            renamer(src.path, dst.path)
+        except OSError, e:
+            if e.errno == errno.EXDEV:
+                raise errors.DifferentLogicalDevices(
+                    'Refusing to move "%s" to "%s" on another filesystem' % (
+                        src.path, dst.path))
+    else:
+        src.moveTo(dst)
+
+
+
+class InterfaceProvidingMetaclass(type):
+    """
+    Metaclass that C{alsoProvides} interfaces specified in
+    C{providedInterfaces}.
+    """
+    providedInterfaces = []
+
+
+    def __new__(cls, name, bases, attrs):
+        newcls = type.__new__(cls, name, bases, attrs)
+        alsoProvides(newcls, *cls.providedInterfaces)
+        return newcls

=== removed directory 'scripts'
=== removed file 'scripts/music.rn'
--- scripts/music.rn	2009-05-07 12:07:49 +0000
+++ scripts/music.rn	1970-01-01 00:00:00 +0000
@@ -1,44 +0,0 @@
-load os
-load audio
-# Store the original filename for later use.
-dup
-
-## Retrieve audio metadata.
-audio.gettags "artist|TPE1,album|TALB,title|TIT2,date|year|TDRC,tracknumber|TRCK" "UNKNOWN"
-# Stack: artist, album, title, date, tracknumber
-expanditer
-var artist
-var album
-var title
-# Replace "/"s in the date with "-"s.
-split "/"
-join "-"
-var date
-# Turn tracknumbers like "1/12" into 1.
-split "/"
-paditer "." 2
-expanditer
-int
-var tracknumber
-pop
-
-# Duplicate the filename again, to determine the extension.
-dup
-audio.extension
-var ext
-
-## Rename the file.
-# Read the filename format from a user config, if available.
-audio.confvar filenameFormat "%(tracknumber)02d. %(title)s%(ext)s"
-format
-os.rename
-
-## Move the file.
-envvar MEDIA_PATH "."
-var media_path
-## Read the directory format from a user config, if available.
-audio.confvar directoryFormat "%(artist)s/%(album)s (%(date)s)"
-format
-os.move
-
-pop

=== removed file 'scripts/tv.rn'
--- scripts/tv.rn	2009-05-04 17:16:25 +0000
+++ scripts/tv.rn	1970-01-01 00:00:00 +0000
@@ -1,44 +0,0 @@
-load os
-load tv
-# Store the original filename for later use.
-dup
-
-## Guess the episode information.
-tv.find_parts
-expanditer
-# Stack: series_name, season, ep, ext
-camel_case_into_sentence
-var series_name
-int
-var season
-int
-var ep
-lower
-var ext
-
-# Retrieve metadata from TV Rage.
-format "%(season)sx%(ep)02d"
-format "%(series_name)s"
-tv.tvrage
-expanditer
-# Stack: series_name, season, ep, name
-var series_name
-var season
-var ep
-var name
-
-## Rename the file.
-# Read the filename format from a user config, if available.
-tv.confvar filenameFormat "%(series_name)s [%(season)sx%(ep)02d] - %(name)s.%(ext)s"
-format
-os.rename
-
-## Move the file.
-envvar MEDIA_PATH "."
-var media_path
-# Read the directory format from a user config, if available.
-tv.confvar directoryFormat "%(media_path)s/%(series_name)s/Season %(season)d"
-format
-os.move
-
-pop

=== modified file 'setup.py'
--- setup.py	2009-05-10 18:57:26 +0000
+++ setup.py	2010-10-10 11:27:40 +0000
@@ -9,7 +9,7 @@
     url="http://launchpad.net/renamer",
     license="MIT",
     platforms=["any"],
-    description="A scriptable and extensible mass file renamer",
+    description="A mass file renamer with plugin support",
     classifiers=[
         "Intended Audience :: End Users/Desktop",
         "Programming Language :: Python",