Merge lp:~renamer-developers/renamer/undo-command into lp:renamer

[Jonathan Jacobs]

[lp:~renamer-developers/renamer/undo-command]

123. By Jonathan Jacobs on 2010-10-18

Handle SystemExit properly in renamer.main.

124. By Jonathan Jacobs on 2010-10-18

Fix typoes.

125. By Jonathan Jacobs on 2010-10-20

Prune even with no-act.

126. By Jonathan Jacobs on 2010-10-20

Remove unused test data.

127. By Jonathan Jacobs on 2010-10-20

Tweak setup.py.

[Jeremy Thurgood (jerith)]

This looks good.

The only concern I have is that it breaks Python 2.5 compat, 2.5 is still the default on a bunch of systems. (Including the box I use renamer on, as it happens.) I'll commit a 2.5 compat fix to this branch and then we're good to go.

review: Approve

[lp:~renamer-developers/renamer/undo-command]

128. By Jeremy Thurgood on 2010-10-24

Bring back Python 2.5 support.

[Tristan Seligmann (mithrandi)]

394 + Remove any L{renamer.history.Action}s that to not have references to a

Typo: to -> do.

701 + status = 0

This creates a local variable "status", which will always mask the global variable that you later set. Move this to module scope to get what I assume was the intended effect.

review: Needs Fixing

[lp:~renamer-developers/renamer/undo-command]

129. By Jonathan Jacobs on 2010-10-24

Address review commentary.

[Jonathan Jacobs (jjacobs)]

> 394 + Remove any L{renamer.history.Action}s that to not have references to
> a
>
> Typo: to -> do.
>
> 701 + status = 0
>
> This creates a local variable "status", which will always mask the global
> variable that you later set. Move this to module scope to get what I assume
> was the intended effect.

Done.

[Tristan Seligmann (mithrandi)]

394 + Remove any L{renamer.history.Action}s that to not have references to a

Typo: to -> do.

701 + status = 0

This creates a local variable "status", which will always mask the global variable that you later set. Move this to module scope to get what I assume was the intended effect.

review: Needs Fixing

[Tristan Seligmann (mithrandi)]

review: Approve

=== modified file 'DEPS'
--- DEPS	2009-05-10 18:57:26 +0000
+++ DEPS	2010-10-24 17:31:17 +0000
@@ -1,3 +1,4 @@
+Axiom 0.6.0
 Epsilon 0.5.0
 Mutagen 1.15
 PyParsing 1.5.1

=== added file 'bin/rn.cmd'
--- bin/rn.cmd	1970-01-01 00:00:00 +0000
+++ bin/rn.cmd	2010-10-24 17:31:17 +0000
@@ -0,0 +1,2 @@
+@echo off
+python -c "from renamer.main import main; main()" %*

=== modified file 'renamer/application.py'
--- renamer/application.py	2010-10-10 10:10:03 +0000
+++ renamer/application.py	2010-10-24 17:31:17 +0000
@@ -1,23 +1,24 @@
 """
 Renamer application logic.
 """
-import glob
+import itertools
 import os
 import string
 import sys
 
-from twisted.internet import reactor, defer
-from twisted.python import usage
+from axiom.store import Store
+
+from twisted.internet import defer
+from twisted.python import usage, log
 from twisted.python.filepath import FilePath
 
 from renamer import logging, plugin, util
-
-
-
-class Options(usage.Options, plugin.RenamerSubCommandMixin):
-    synopsis = '[options] command argument [argument ...]'
-
-
+from renamer.irenamer import IRenamingCommand
+from renamer.history import History
+
+
+
+class Options(usage.Options, plugin._CommandMixin):
     optFlags = [
         ('glob',            'g',  'Expand arguments as UNIX-style globs.'),
         ('one-file-system', 'x',  "Don't cross filesystems."),
@@ -37,7 +38,9 @@
 
     @property
     def subCommands(self):
-        for plg in plugin.getPlugins():
+        commands = itertools.chain(
+            plugin.getRenamingCommands(), plugin.getCommands())
+        for plg in commands:
             try:
                 yield plg.name, None, plg, plg.description
             except AttributeError:
@@ -49,6 +52,12 @@
         self['verbosity'] = 1
 
 
+    @property
+    def synopsis(self):
+        return 'Usage: %s [options]' % (
+            os.path.basename(sys.argv[0]),)
+
+
     def opt_verbose(self):
         """
         Increase output, use more times for greater effect.
@@ -67,35 +76,11 @@
     opt_q = opt_quiet
 
 
-    def glob(self, args):
-        """
-        Glob arguments.
-        """
-        def _glob():
-            return (arg
-                for _arg in args
-                for arg in glob.glob(_arg))
-
-        def _globWin32():
-            for arg in args:
-                if not os.path.exists(arg):
-                    globbed = glob.glob(arg)
-                    if globbed:
-                        for a in globbed:
-                            yield a
-                        continue
-                yield arg
-
-        if sys.platform == 'win32':
-            return _globWin32()
-        return _glob()
-
-
     def parseArgs(self, *args):
         args = (self.decodeCommandLine(arg) for arg in args)
         if self['glob']:
-            args = self.glob(args)
-        self.args = [FilePath(arg) for arg in args]
+            args = util.globArguments(args)
+        self.args = (FilePath(arg) for arg in args)
 
 
 
@@ -103,96 +88,115 @@
     """
     Renamer main logic.
 
+    @type store: L{axiom.store.Store}
+    @ivar store: Renamer database Store.
+
+    @type history: L{renamer.history.History}
+    @ivar history: Renamer history Item.
+
     @type options: L{renamer.application.Options}
     @ivar options: Parsed command-line options.
+
+    @type command: L{renamer.irenamer.ICommand}
+    @ivar command: Renamer command being executed.
     """
-    def __init__(self, options):
-        self.options = options
-
-
-    def rename(self, dst, src):
-        """
-        Rename C{src} to {dst}.
-
-        Perform symlinking if specified and create any required directory
-        hiearchy.
+    def __init__(self):
+        obs = logging.RenamerObserver()
+        log.startLoggingWithObserver(obs.emit, setStdout=False)
+
+        self.store = Store(os.path.expanduser('~/.renamer/renamer.axiom'))
+        # XXX: One day there might be more than one History item.
+        self.history = self.store.findOrCreate(History)
+
+        self.options = Options()
+        self.options.parseOptions()
+        obs.verbosity = self.options['verbosity']
+        self.command = self.getCommand()
+
+
+    def getCommand(self):
+        """
+        Get the L{twisted.python.usage.Options} command that was invoked.
+        """
+        command = getattr(self.options, 'subOptions', None)
+        if command is None:
+            raise usage.UsageError('At least one command must be specified')
+
+        while getattr(command, 'subOptions', None) is not None:
+            command = command.subOptions
+
+        return command
+
+
+    def performRename(self, dst, src):
+        """
+        Perform a file rename.
         """
         options = self.options
-
-        if options['dry-run']:
-            logging.msg('Dry-run: %s => %s' % (src.path, dst.path))
+        if options['no-act']:
+            logging.msg('Simulating: %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)
+            self.changeset.do(
+                self.changeset.newAction(u'symlink', src, dst),
+                options)
         else:
-            logging.msg('Move: %s => %s' % (src.path, dst.path))
-            util.rename(src, dst, oneFileSystem=options['one-file-system'])
+            self.changeset.do(
+                self.changeset.newAction(u'move', src, dst),
+                options)
             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):
+                self.changeset.do(
+                    self.changeset.newAction(u'symlink', dst, src),
+                    options)
+
+
+    def runCommand(self, command):
+        """
+        Run a generic command.
+        """
+        return defer.maybeDeferred(command.process, self)
+
+
+    def runRenamingCommand(self, command):
+        """
+        Run a renaming command.
+        """
+        def _processOne(src):
+            self.currentArgument = src
+            d = self.runCommand(command)
+            d.addCallback(self.performRename, src)
+            return d
+
+        self.changeset = self.history.newChangeset()
         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 util.parallel(
+            self.options.args, self.options['concurrent'], _processOne)
+
+
+    def run(self):
+        """
+        Begin processing commands.
+        """
+        if IRenamingCommand(type(self.command), None) is not None:
+            d = self.runRenamingCommand(self.command)
+        else:
+            d = self.runCommand(self.command)
+        d.addCallback(self.exit)
         return d
+
+
+    def exit(self, ignored):
+        """
+        Perform the exit routine.
+        """
+        # We can safely do this even with "no-act", since nothing was actioned
+        # and there is no point leaving orphaned Items around.
+        self.history.pruneChangesets()

=== modified file 'renamer/errors.py'
--- renamer/errors.py	2010-10-10 10:10:03 +0000
+++ renamer/errors.py	2010-10-24 17:31:17 +0000
@@ -9,3 +9,17 @@
     """
     An attempt to move a file to a different logical device was made.
     """
+
+
+
+class NoSuchAction(ValueError):
+    """
+    An invalid or unknown action name was specified.
+    """
+
+
+
+class NoClobber(RuntimeError):
+    """
+    A destination file already exists.
+    """

=== added file 'renamer/history.py'
--- renamer/history.py	1970-01-01 00:00:00 +0000
+++ renamer/history.py	2010-10-24 17:31:17 +0000
@@ -0,0 +1,243 @@
+from epsilon.extime import Time
+
+from twisted.python.components import registerAdapter
+from twisted.python.filepath import FilePath
+
+from axiom.attributes import reference, text, timestamp
+from axiom.item import Item, transacted
+
+from renamer import logging
+from renamer.irenamer import IRenamingAction
+from renamer.plugin import getActionByName
+
+
+
+class History(Item):
+    """
+    Changeset management.
+    """
+    created = timestamp(doc="""
+    Timestamp of when the history was first created.
+    """, defaultFactory=lambda: Time())
+
+
+    def getChangesets(self):
+        """
+        Get L{renamer.history.Changeset}s for this history.
+        """
+        return iter(self.store.query(
+            Changeset,
+            Changeset.history == self,
+            sort=Changeset.modified.ascending))
+
+
+    @transacted
+    def pruneChangesets(self):
+        """
+        Prune empty changesets from the currently active changesets.
+        """
+        prunedChangesets = 0
+        prunedActions = self.pruneActions()
+        for cs in self.store.query(Changeset):
+            if not cs.numActions:
+                cs.deleteFromStore()
+                prunedChangesets += 1
+            elif cs.history is None:
+                cs.history = self
+
+        logging.msg(
+            'Pruned %d changesets' % (prunedChangesets,),
+            verbosity=3)
+
+        return prunedChangesets, prunedActions
+
+
+    @transacted
+    def pruneActions(self):
+        """
+        Remove any L{renamer.history.Action}s that do not have references to a
+        L{renamer.history.Changeset}. These are actions most likely created and
+        never used, so there is no need to store them.
+        """
+        count = 0
+        for action in self.store.query(Action, Action.changeset == None):
+            action.deleteFromStore()
+            count += 1
+
+        logging.msg(
+            'Pruned %d actions' % (count,),
+            verbosity=3)
+
+        return count
+
+
+    def newChangeset(self):
+        """
+        Begin a new changeset.
+
+        @rtype: L{renamer.history.Changeset}
+        """
+        return Changeset(
+            store=self.store)
+
+
+
+class Changeset(Item):
+    """
+    A history changeset containing at least one action.
+    """
+    created = timestamp(doc="""
+    Timestamp of when the changeset was first created.
+    """, defaultFactory=lambda: Time())
+
+
+    modified = timestamp(doc="""
+    Timestamp of when the changeset was last modified.
+    """, defaultFactory=lambda: Time())
+
+
+    history = reference(doc="""
+    Parent history Item.
+    """, reftype=History, whenDeleted=reference.CASCADE)
+
+
+    def __repr__(self):
+        return '<%s %d action(s) created=%r modified=%r>' % (
+            type(self).__name__,
+            self.numActions,
+            self.created,
+            self.modified)
+
+
+    def getActions(self):
+        """
+        Get an iterable of L{renamer.history.Action}s for this changeset,
+        sorted by ascending order of creation.
+        """
+        return iter(
+            self.store.query(
+                Action,
+                Action.changeset == self,
+                sort=Action.created.ascending))
+
+
+    @property
+    def numActions(self):
+        """
+        Number of actions contained in this changeset.
+        """
+        return self.store.query(Action, Action.changeset == self).count()
+
+
+    def asHumanly(self):
+        """
+        Construct a human readable representation of the changeset.
+        """
+        return u'Changeset with %d action(s) (%s)' % (
+            self.numActions,
+            self.modified.asHumanly())
+
+
+    def newAction(self, name, src, dst, verify=True):
+        """
+        Create a new L{renamer.history.Action}.
+        """
+        if verify:
+            # Check that "name" is in fact a valid action.
+            getActionByName(name)
+        return Action(
+            store=self.store,
+            name=name,
+            src=src.path,
+            dst=dst.path)
+
+
+    @transacted
+    def do(self, action, options, _adapter=IRenamingAction):
+        """
+        Perform an action.
+
+        @type  action: L{renamer.history.Action}
+
+        @type  options: L{twisted.python.usage.Options}
+        """
+        renamingAction = _adapter(action)
+        renamingAction.do(options)
+        action.changeset = self
+        self.modified = Time()
+
+
+    @transacted
+    def undo(self, action, options, _adapter=IRenamingAction):
+        """
+        Perform a reverse action.
+
+        @type  action: L{renamer.irenamer.IRenamingAction}
+
+        @type  options: L{twisted.python.usage.Options}
+        """
+        renamingAction = _adapter(action)
+        renamingAction.undo(options)
+        action.deleteFromStore()
+        self.modified = Time()
+
+
+
+class Action(Item):
+    """
+    A single action in a changeset.
+
+    Can be adapted to L{renamer.irenamer.IRenamingAction}.
+    """
+    created = timestamp(doc="""
+    Timestamp of when the action was first created.
+    """, defaultFactory=lambda: Time())
+
+
+    name = text(doc="""
+    Action name, should be a value that can be passed to
+    L{renamer.plugin.getActionByName}.
+    """, allowNone=False)
+
+
+    src = text(doc="""
+    Path to the source file of the action.
+    """, allowNone=False)
+
+
+    dst = text(doc="""
+    Path to the destination file of the action.
+    """, allowNone=False)
+
+
+    changeset = reference(doc="""
+    Parent changeset Item.
+    """, reftype=Changeset, whenDeleted=reference.CASCADE)
+
+
+    def __repr__(self):
+        return '<%s name=%r src=%r dst=%r created=%r>' % (
+            type(self).__name__,
+            self.name,
+            self.src,
+            self.dst,
+            self.created)
+
+
+    def asHumanly(self):
+        """
+        Construct a human readable representation of the action.
+        """
+        return u'%s: %s => %s (%s)' % (
+            self.name.title(), self.src, self.dst, self.created.asHumanly())
+
+
+    def toRenamingAction(self):
+        """
+        Create a L{renamer.irenamer.IRenamingAction} from this Item.
+        """
+        return getActionByName(self.name)(
+            src=FilePath(self.src),
+            dst=FilePath(self.dst))
+
+registerAdapter(Action.toRenamingAction, Action, IRenamingAction)

=== modified file 'renamer/irenamer.py'
--- renamer/irenamer.py	2010-09-29 16:58:00 +0000
+++ renamer/irenamer.py	2010-10-24 17:31:17 +0000
@@ -2,9 +2,9 @@
 
 
 
-class IRenamerCommand(Interface):
+class ICommand(Interface):
     """
-    Renamer command.
+    Generic Renamer command.
     """
     name = Attribute("""
     Command name.
@@ -16,9 +16,25 @@
     """)
 
 
-    defaultNameFormat = Attribute("""
-    String template for the default name format to use if one is not supplied
-    to Renamer.
+    def process(renamer):
+        """
+        Called once command line parsing is complete.
+        """
+
+
+
+class IRenamingCommand(ICommand):
+    """
+    Command that performs renaming on one argument at a time.
+    """
+    defaultNameTemplate = Attribute("""
+    String template for the default name format to use if one is not supplied.
+    """)
+
+
+    defaultPrefixTemplate = Attribute("""
+    String template for the default prefix format to use if one is not
+    supplied.
     """)
 
 
@@ -30,3 +46,34 @@
         @return: Mapping of keys to values to substitute info the name
             template.
         """
+
+
+
+class IRenamingAction(Interface):
+    """
+    An action that performs some renaming-related function and is undoable.
+    """
+    src = Attribute("""
+    L{twisted.python.filepath.FilePath} to the source file.
+    """)
+
+
+    dst = Attribute("""
+    L{twisted.python.filepath.FilePath} to the destination file.
+    """)
+
+
+    def do(options):
+        """
+        Perform the action.
+
+        @type  options: L{twisted.python.usage.Options}
+        """
+
+
+    def undo(options):
+        """
+        Perform the reverse action.
+
+        @type  options: L{twisted.python.usage.Options}
+        """

=== modified file 'renamer/logging.py'
--- renamer/logging.py	2010-09-29 23:30:45 +0000
+++ renamer/logging.py	2010-10-24 17:31:17 +0000
@@ -8,7 +8,7 @@
     """
     Twisted event log observer for Renamer.
     """
-    def __init__(self, verbosity):
+    def __init__(self, verbosity=1):
         self.verbosity = verbosity
 
 

=== modified file 'renamer/main.py'
--- renamer/main.py	2010-09-29 15:37:22 +0000
+++ renamer/main.py	2010-10-24 17:31:17 +0000
@@ -1,17 +1,43 @@
-from twisted.python import log
-from twisted.internet import reactor
-
-from renamer import application
-from renamer.logging import RenamerObserver
+import os, sys
+
+from twisted.python import failure, usage
+from twisted.internet import defer, reactor
+
+from renamer import application, logging
+
+
+
+status = 0
+
 
 
 def main():
-    options = application.Options()
-    options.parseOptions()
-
-    obs = RenamerObserver(options['verbosity'])
-    log.startLoggingWithObserver(obs.emit, setStdout=False)
-
-    r = application.Renamer(options)
-    reactor.callWhenRunning(r.run)
+    def logError(f):
+        logging.err(f)
+        global status
+        status = 1
+
+    def usageError(f):
+        f.trap(usage.UsageError)
+        prog = os.path.basename(sys.argv[0])
+        sys.stderr.write('%s: %s\n' % (prog, f.value))
+        sys.stderr.write('Consult --help for usage information\n')
+        global status
+        status = 1
+
+    def run():
+        try:
+            d = defer.succeed(application.Renamer())
+        except SystemExit:
+            d = defer.succeed(None)
+        except:
+            d = defer.fail(failure.Failure())
+        else:
+            d.addCallback(lambda r: r.run())
+        d.addErrback(usageError)
+        d.addErrback(logError)
+        d.addBoth(lambda ign: reactor.stop())
+
+    reactor.callWhenRunning(run)
     reactor.run()
+    sys.exit(status)

=== modified file 'renamer/plugin.py'
--- renamer/plugin.py	2010-10-10 11:25:05 +0000
+++ renamer/plugin.py	2010-10-24 17:31:17 +0000
@@ -1,24 +1,64 @@
+import os
+import string
 import sys
 from zope.interface import noLongerProvides
 
-from twisted import plugin
+from twisted.plugin import getPlugins, IPlugin
+from twisted.internet import defer
 from twisted.python import usage
+from twisted.python.filepath import FilePath
 
-from renamer import plugins
-from renamer.irenamer import IRenamerCommand
+from renamer import errors, logging, plugins
+from renamer.irenamer import ICommand, IRenamingCommand, IRenamingAction
 from renamer.util import InterfaceProvidingMetaclass
 
 
 
-def getPlugins():
-    """
-    Get all available Renamer plugins.
-    """
-    return plugin.getPlugins(IRenamerCommand, plugins)
-
-
-
-class RenamerSubCommandMixin(object):
+def getCommands():
+    """
+    Get all available L{renamer.irenamer.ICommand}s.
+    """
+    return getPlugins(ICommand, plugins)
+
+
+
+def getRenamingCommands():
+    """
+    Get all available L{renamer.irenamer.IRenamingCommand}s.
+    """
+    return getPlugins(IRenamingCommand, plugins)
+
+
+
+def getActions():
+    """
+    Get all available L{renamer.irenamer.IRenamingAction}s.
+    """
+    return getPlugins(IRenamingAction, plugins)
+
+
+
+def getActionByName(name):
+    """
+    Get an L{renamer.irenamer.IRenamingAction} by name.
+
+    @type name: C{unicode}
+    @param name: Action name.
+
+    @raises L{renamer.errors.NoSuchAction}: If no action named C{name} could be
+        found.
+
+    @rtype: L{renamer.irenamer.IRenamingAction}
+    """
+    for action in getActions():
+        if action.name == name:
+            return action
+
+    raise errors.NoSuchAction(name)
+
+
+
+class _CommandMixin(object):
     """
     Mixin for Renamer commands.
     """
@@ -30,37 +70,205 @@
         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
+    # ICommand
+
+    def process(self, renamer):
+        raise NotImplementedError('Commands must implement "process"')
+
+
+
+class CommandMeta(InterfaceProvidingMetaclass):
+    providedInterfaces = [IPlugin, ICommand]
+
+
+
+class Command(_CommandMixin, usage.Options):
+    """
+    Top-level generic command.
+
+    This command will display in the main help listing.
+    """
+    __metaclass__ = CommandMeta
+
+noLongerProvides(Command, IPlugin)
+noLongerProvides(Command, ICommand)
+
+
+
+class SubCommand(_CommandMixin, usage.Options):
+    """
+    Sub-level generic command.
+    """
+
+
+
+class RenamingCommandMeta(InterfaceProvidingMetaclass):
+    providedInterfaces = [IPlugin, IRenamingCommand]
+
+
+
+class RenamingCommand(_CommandMixin, usage.Options):
+    """
+    Top-level renaming command.
+
+    This command will display in the main help listing.
+    """
+    __metaclass__ = RenamingCommandMeta
+
+
+    synopsis = '[options] <argument> [argument ...]'
+
+
+    # IRenamingCommand
 
     defaultPrefixTemplate = None
     defaultNameTemplate = None
 
 
+    def buildDestination(self, mapping, options, src):
+        """
+        Build a destination path.
+
+        Substitution of C{mapping} into the C{'prefix'} command-line option
+        (defaulting to L{defaultPrefixTemplate}) and the C{'name'} command-line
+        option (defaulting to L{defaultNameTemplate}) is performed.
+
+        @type  mapping: C{dict} mapping C{str} to C{unicode}
+        @param mapping: Mapping of template variables, used for template
+            substitution.
+
+        @type  options: L{twisted.python.usage.Options}
+
+        @type  src: L{twisted.python.filepath.FilePath}
+        @param src: Source path.
+
+        @rtype:  L{twisted.python.filepath.FilePath}
+        @return: Destination path.
+        """
+        prefixTemplate = options['prefix']
+        if prefixTemplate is None:
+            prefixTemplate = self.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 = options['name']
+        if nameTemplate is None:
+            nameTemplate = self.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)
+
+
     def parseArgs(self, *args):
+        # Parse args like our parent (hopefully renamer.application.Options)
+        # which decodes and unglobs stuff.
+        # XXX: This is probably not great.
         self.parent.parseArgs(*args)
 
 
-    def postOptions(self):
-        self.parent.command = self
-
-noLongerProvides(RenamerCommand, plugin.IPlugin)
-noLongerProvides(RenamerCommand, IRenamerCommand)
+    # ICommand
+
+    def process(self, renamer):
+        arg = renamer.currentArgument
+        logging.msg('Processing "%s"' % (arg.path,),
+                    verbosity=3)
+        d = defer.maybeDeferred(self.processArgument, arg)
+        d.addCallback(self.buildDestination, renamer.options, arg)
+        return d
+
+
+    # IRenamingCommand
+
+    def processArgument(self, argument):
+        raise NotImplementedError(
+            'RenamingCommands must implement "processArgument"')
+
+noLongerProvides(RenamingCommand, IPlugin)
+noLongerProvides(RenamingCommand, IRenamingCommand)
+
+
+
+class RenamingActionMeta(InterfaceProvidingMetaclass):
+    providedInterfaces = [IPlugin, IRenamingAction]
+
+
+
+class RenamingAction(object):
+    """
+    An action that performs some renaming-related function and is undoable.
+
+    @see: L{renamer.irenamer.IRenamingAction}
+    """
+    __metaclass__ = RenamingActionMeta
+
+
+    def __init__(self, src, dst):
+        self.src = src
+        self.dst = dst
+
+
+    def __repr__(self):
+        return '<%s name=%r src=%r dst=%r>' % (
+            type(self).__name__,
+            self.name,
+            self.src,
+            self.dst)
+
+
+    def makedirs(self, parent):
+        """
+        Create any directory structure that does not yet exist.
+        """
+        if not parent.exists():
+            logging.msg('Creating directory structure for "%s"' % (
+                parent.path,), verbosity=2)
+            parent.makedirs()
+
+
+    def checkExisting(self, dst):
+        """
+        Ensure that the destination file does not yet exist.
+        """
+        if dst.exists():
+            msg = 'Refusing to clobber existing file "%s"' % (
+                dst.path,)
+            logging.msg(msg)
+            raise errors.NoClobber(msg)
+
+
+    def prepare(self, dst, options):
+        """
+        Prepare for an action about to be performed.
+
+        The following preparations are done:
+
+            * Check that C{dst} does not already exist.
+
+            * Create any directory structure required for C{dst}.
+        """
+        self.checkExisting(dst)
+        self.makedirs(dst.parent())
+
+
+    # IRenamingAction
+
+    def do(self, options):
+        raise NotImplementedError('Base classes must implement "do"')
+
+
+    def undo(self, options):
+        raise NotImplementedError('Base classes must implement "undo"')
+
+noLongerProvides(RenamingAction, IPlugin)
+noLongerProvides(RenamingAction, IRenamingAction)

=== added file 'renamer/plugins/actions.py'
--- renamer/plugins/actions.py	1970-01-01 00:00:00 +0000
+++ renamer/plugins/actions.py	2010-10-24 17:31:17 +0000
@@ -0,0 +1,52 @@
+from renamer import logging, util
+from renamer.plugin import RenamingAction
+
+
+
+class MoveAction(RenamingAction):
+    """
+    File move action.
+
+    If the source and destination are on different logical devices a
+    copy-delete will be used, unless the C{'one-file-system'} option is
+    specified.
+    """
+    name = 'move'
+
+
+    def _move(self, src, dst, options):
+        self.prepare(dst, options)
+        logging.msg('Move: %s => %s' % (src.path, dst.path))
+        util.rename(src, dst, oneFileSystem=options['one-file-system'])
+
+
+    # IRenamingAction
+
+    def do(self, options):
+        self._move(self.src, self.dst, options)
+
+
+    def undo(self, options):
+        self._move(self.dst, self.src, options)
+
+
+
+class SymlinkAction(RenamingAction):
+    """
+    Symlink action.
+    """
+    name = 'symlink'
+
+
+    # IRenamingAction
+
+    def do(self, options):
+        self.prepare(self.dst, options)
+        logging.msg('Symlink: %s => %s' % (self.src.path, self.dst.path))
+        self.src.linkTo(self.dst)
+
+
+    def undo(self, options):
+        if self.dst.islink():
+            logging.msg('Symlink: Removing %s' % (self.dst.path,))
+            self.dst.remove()

=== modified file 'renamer/plugins/audio.py'
--- renamer/plugins/audio.py	2010-09-29 23:30:45 +0000
+++ renamer/plugins/audio.py	2010-10-24 17:31:17 +0000
@@ -8,12 +8,12 @@
     mutagen = None
 
 from renamer import logging
-from renamer.plugin import RenamerCommand
+from renamer.plugin import RenamingCommand
 from renamer.errors import PluginError
 
 
 
-class Audio(RenamerCommand):
+class Audio(RenamingCommand):
     name = 'audio'
 
 
@@ -41,7 +41,6 @@
         if mutagen is None:
             raise PluginError(
                 'The "mutagen" package is required for this command')
-        super(Audio, self).postOptions()
         self._metadataCache = {}
 
 
@@ -77,6 +76,7 @@
 
         return default
 
+
     def _saneTracknumber(self, tracknumber):
         if u'/' in tracknumber:
             tracknumber = tracknumber.split(u'/')[0]

=== modified file 'renamer/plugins/tv.py'
--- renamer/plugins/tv.py	2010-10-10 10:13:42 +0000
+++ renamer/plugins/tv.py	2010-10-24 17:31:17 +0000
@@ -13,12 +13,12 @@
     pyparsing = None
 
 from renamer import logging
-from renamer.plugin import RenamerCommand
+from renamer.plugin import RenamingCommand
 from renamer.errors import PluginError
 
 
 
-class TVRage(RenamerCommand):
+class TVRage(RenamingCommand):
     name = 'tvrage'
 
 
@@ -40,7 +40,6 @@
 
 
     def postOptions(self):
-        super(TVRage, self).postOptions()
         self.filenameParser = self._createParser()
 
 

=== added file 'renamer/plugins/undo.py'
--- renamer/plugins/undo.py	1970-01-01 00:00:00 +0000
+++ renamer/plugins/undo.py	2010-10-24 17:31:17 +0000
@@ -0,0 +1,175 @@
+from twisted.python import usage
+
+from renamer import logging
+from renamer.history import Action, Changeset
+from renamer.plugin import Command, SubCommand
+
+
+
+def getItem(store, storeID, acceptableTypes):
+    """
+    Get an Axiom Item from a store by ID and verify that it is an acceptable
+    type.
+    """
+    try:
+        storeID = int(storeID)
+    except (ValueError, TypeError):
+        raise usage.UsageError(
+            'Identifier %r is not an integer' % (storeID,))
+    else:
+        item = store.getItemByID(storeID, default=None)
+        if not isinstance(item, acceptableTypes):
+            raise usage.UsageError(
+                'Invalid identifier %r' % (storeID,))
+        return item
+
+
+
+class _UndoMixin(object):
+    optFlags = [
+        ('ignore-errors', None, 'Do not stop the process when encountering OS errors')]
+
+
+    def undoActions(self, renamer, changeset, actions):
+        """
+        Undo specific actions from a changeset.
+        """
+        for action in actions:
+            msg = 'Simulating undo'
+            if not renamer.options['no-act']:
+                msg = 'Undo'
+
+            logging.msg('%s: %s' % (msg, action.asHumanly()), verbosity=3)
+            if not renamer.options['no-act']:
+                try:
+                    changeset.undo(action, renamer.options)
+                except OSError, e:
+                    if not self['ignore-errors']:
+                        raise e
+                    logging.msg('Ignoring %r' % (e,), verbosity=3)
+
+
+
+class UndoAction(SubCommand, _UndoMixin):
+    name = 'action'
+
+
+    synopsis = '[options] <actionID>'
+
+
+    longdesc = """
+    Undo a single action from a changeset. Consult "undo list" for action
+    identifiers.
+    """
+
+
+    def parseArgs(self,  action):
+        self['action'] = action
+
+
+    def process(self, renamer):
+        action = getItem(renamer.store, self['action'], Action)
+        self.undoActions(
+            renamer, action.changeset, [action])
+
+
+
+class UndoChangeset(SubCommand, _UndoMixin):
+    name = 'changeset'
+
+
+    synopsis = '[options] <changesetID>'
+
+
+    longdesc = """
+    Undo an entire changeset. Consult "undo list" for changeset identifiers.
+    """
+
+
+    def parseArgs(self, changeset):
+        self['changeset'] = changeset
+
+
+    def process(self, renamer):
+        changeset = getItem(renamer.store, self['changeset'], Changeset)
+        logging.msg('Undoing: %s' % (changeset.asHumanly(),),
+                    verbosity=3)
+        actions = list(changeset.getActions())
+        self.undoActions(
+            renamer, changeset, reversed(actions))
+
+
+
+class UndoList(SubCommand):
+    name = 'list'
+
+
+    longdesc = """
+    List undoable changesets and actions.
+    """
+
+
+    def process(self, renamer):
+        changesets = list(renamer.history.getChangesets())
+        for cs in changesets:
+            print 'Changeset ID=%d:  %s' % (cs.storeID, cs.asHumanly())
+            for a in cs.getActions():
+                print '   Action ID=%d:  %s' % (a.storeID, a.asHumanly())
+            print
+
+        if not changesets:
+            print 'No changesets!'
+
+
+
+class UndoForget(SubCommand):
+    name = 'forget'
+
+
+    synopsis = '<identifier>'
+
+
+    longdesc = """
+    Forget (permanently remove) an undo history action or entire changeset.
+    Consult "undo list" for identifiers.
+    """
+
+
+    def parseArgs(self, identifier):
+        self['identifier'] = identifier
+
+
+    def process(self, renamer):
+        item = getItem(renamer.store, self['identifier'], (Action, Changeset))
+        if not renamer.options['no-act']:
+            logging.msg('Forgetting: %s' % (item.asHumanly(),), verbosity=2)
+            item.deleteFromStore()
+
+
+
+class Undo(Command):
+    name = 'undo'
+
+
+    description = 'Undo previous Renamer actions'
+
+
+    longdesc = """
+    Every invocation of Renamer stores the actions taken as a changeset, this
+    allows Renamer to undo entire changesets or previously performed individual
+    actions.
+
+    Undo actions are communicated by identifiers, which can be discovered by
+    consulting "undo list".
+    """
+
+
+    subCommands = [
+        ('action',    None, UndoAction,    'Undo a single action from a changeset'),
+        ('changeset', None, UndoChangeset, 'Undo a whole changeset'),
+        ('forget',    None, UndoForget,    'Forget an undo history item'),
+        ('list',      None, UndoList,      'List changesets')]
+
+
+    def parseArgs(self, *args):
+        raise usage.UsageError('Issue an undo subcommand to perform')

=== added file 'renamer/test/test_actions.py'
--- renamer/test/test_actions.py	1970-01-01 00:00:00 +0000
+++ renamer/test/test_actions.py	2010-10-24 17:31:17 +0000
@@ -0,0 +1,173 @@
+from twisted.python.filepath import FilePath
+from twisted.trial.unittest import TestCase
+
+from renamer import errors
+from renamer.application import Options
+from renamer.plugins import actions
+
+
+
+class _ActionTestMixin(object):
+    actionType = None
+
+
+    def setUp(self):
+        self.path = FilePath(self.mktemp())
+        self.path.makedirs()
+        self.options = Options()
+        self.src, self.dst = self.createFiles()
+
+
+    def createFiles(self):
+        """
+        Create paths for source and destination files.
+        """
+        return self.path.child('src'), self.path.child('dst')
+
+
+    def createAction(self, src=None, dst=None):
+        """
+        Create an action from L{actionType}.
+        """
+        if src is None:
+            src = self.src
+        if dst is None:
+            dst = self.dst
+        return self.actionType(src, dst)
+
+
+    def test_do(self):
+        """
+        Perform the action.
+        """
+
+
+    def test_doWithSubdirs(self):
+        """
+        Performing an action involving a subdirectory results in that
+        subdirectory being created if it didn't already exist.
+        """
+        self.dst = self.path.child('subdir').child('dst')
+        parent = self.dst.parent()
+        self.assertFalse(parent.exists())
+        self.test_do()
+        self.assertTrue(parent.exists())
+        self.assertEquals(parent.listdir(), ['dst'])
+
+
+    def test_doClobber(self):
+        """
+        Performing an action raises L{renames.errors.NoClobber} when the
+        destination file already exists.
+        """
+        self.dst.touch()
+        action = self.createAction()
+        self.assertRaises(
+            errors.NoClobber, action.do, self.options)
+
+
+    def test_undo(self):
+        """
+        Perform the reverse action.
+        """
+
+
+    def test_undoWithSubdirs(self):
+        """
+        Performing a reverse action does not remove existing directories.
+        """
+        self.dst = self.path.child('subdir').child('dst')
+        parent = self.dst.parent()
+        parent.makedirs()
+        self.assertTrue(parent.exists())
+        self.test_undo()
+        self.assertTrue(parent.exists())
+        self.assertEquals(parent.listdir(), [])
+
+
+    def test_undoClobber(self):
+        """
+        Performing a reverse action raises L{renames.errors.NoClobber} when the
+        destination file already exists.
+        """
+        self.src.touch()
+        action = self.createAction()
+        self.assertRaises(
+            errors.NoClobber, action.undo, self.options)
+
+
+
+class MoveActionTests(_ActionTestMixin, TestCase):
+    """
+    Tests for L{renamer.plugins.actions.MoveAction}.
+    """
+    actionType = actions.MoveAction
+
+
+    def test_do(self):
+        self.src.touch()
+
+        self.assertTrue(self.src.exists())
+        self.assertFalse(self.dst.exists())
+
+        action = self.createAction()
+        action.do(self.options)
+
+        self.assertFalse(self.src.exists())
+        self.assertTrue(self.dst.exists())
+
+
+    def test_undo(self):
+        self.dst.touch()
+
+        self.assertFalse(self.src.exists())
+        self.assertTrue(self.dst.exists())
+
+        action = self.createAction()
+        action.undo(self.options)
+
+        self.assertTrue(self.src.exists())
+        self.assertFalse(self.dst.exists())
+
+
+
+class SymlinkActionTests(_ActionTestMixin, TestCase):
+    """
+    Tests for L{renamer.plugins.actions.SymlinkAction}.
+    """
+    actionType = actions.SymlinkAction
+
+
+    def test_do(self):
+        self.src.touch()
+
+        self.assertTrue(self.src.exists())
+        self.assertFalse(self.dst.exists())
+
+        action = self.createAction()
+        action.do(self.options)
+
+        self.assertTrue(self.src.exists())
+        self.assertTrue(self.dst.exists())
+        self.assertTrue(self.dst.islink())
+
+
+    def test_undo(self):
+        self.src.touch()
+        self.src.linkTo(self.dst)
+
+        self.assertTrue(self.src.exists())
+        self.assertTrue(self.dst.exists())
+        self.assertTrue(self.dst.islink())
+
+        action = self.createAction()
+        action.undo(self.options)
+
+        self.assertTrue(self.src.exists())
+        self.assertFalse(self.dst.exists())
+
+
+    def test_undoClobber(self):
+        """
+        Undoing a symlink cannot raise L{renamer.errors.NoClobber}.
+        """

=== added file 'renamer/test/test_history.py'
--- renamer/test/test_history.py	1970-01-01 00:00:00 +0000
+++ renamer/test/test_history.py	2010-10-24 17:31:17 +0000
@@ -0,0 +1,186 @@
+from axiom.store import Store
+
+from twisted.python.filepath import FilePath
+from twisted.trial.unittest import TestCase
+
+from renamer import errors, history, irenamer
+from renamer.plugins.actions import SymlinkAction
+
+
+
+def FakeOptions():
+    return {}
+
+
+
+class FakeAction(object):
+    def do(self, options):
+        pass
+
+
+    def undo(self, options):
+        pass
+
+
+
+class HistoryTests(TestCase):
+    """
+    Tests for L{renamer.history.History}.
+    """
+    def setUp(self):
+        self.store = Store()
+        self.history = history.History(store=self.store)
+
+
+    def test_newChangeset(self):
+        """
+        L{renamer.history.History.newChangeset} creates a new changeset
+        instance and does not track it immediately.
+        """
+        cs = self.history.newChangeset()
+        self.assertIdentical(type(cs), history.Changeset)
+        self.assertEquals(list(self.history.getChangesets()), [])
+
+
+    def test_pruneChangesets(self):
+        """
+        L{renamer.history.History.pruneChangesets} removes empty changesets
+        (changesets without any actions) from the database.
+        """
+        cs = self.history.newChangeset()
+        self.assertEquals(list(self.history.getChangesets()), [])
+
+        action = cs.newAction(
+            u'fake', FilePath(u'src'), FilePath(u'dst'), verify=False)
+
+        # Unused action.
+        cs.newAction(
+            u'fake', FilePath(u'src'), FilePath(u'dst'), verify=False)
+
+        self.assertEquals(list(cs.getActions()), [])
+        self.assertEquals(cs.numActions, 0)
+
+        def _adapter(action):
+            return FakeAction()
+
+        cs.do(action, FakeOptions(), _adapter=_adapter)
+
+        self.assertEquals(
+            list(cs.getActions()), [action])
+        self.assertEquals(cs.numActions, 1)
+        prunedChangesets, prunedActions = self.history.pruneChangesets()
+        self.assertEquals(prunedChangesets, 0)
+        self.assertEquals(prunedActions, 1)
+        self.assertEquals(list(self.history.getChangesets()), [cs])
+
+        cs.undo(action, FakeOptions(), _adapter=_adapter)
+        self.assertEquals(list(cs.getActions()), [])
+        self.assertEquals(cs.numActions, 0)
+        prunedChangesets, prunedActions = self.history.pruneChangesets()
+        self.assertEquals(prunedChangesets, 1)
+        self.assertEquals(prunedActions, 0)
+        self.assertEquals(list(self.history.getChangesets()), [])
+
+
+
+class ChangesetTests(TestCase):
+    """
+    Tests for L{renamer.history.Changeset}.
+    """
+    def setUp(self):
+        self.store = Store()
+        self.history = history.History(store=self.store)
+
+
+    def test_newInvalidAction(self):
+        """
+        L{renamer.history.Changeset.newAction} raises
+        L{renamer.errors.NoSuchAction} if the action name specified does not
+        refer to a valid action.
+        """
+        cs = self.history.newChangeset()
+        self.assertRaises(errors.NoSuchAction,
+            cs.newAction, 'THIS_IS_NOT_REAL', FilePath(u'a'), FilePath(u'b'))
+
+
+    def test_representations(self):
+        """
+        L{renamer.history.Changeset.asHumanly} returns a human-readable and
+        accurate representation of a changeset.
+
+        L{renamer.history.Changeset.__repr__} returns a useful and accurate
+        representation of a changeset.
+        """
+        cs = self.history.newChangeset()
+
+        self.assertTrue(
+            cs.asHumanly().startswith(
+                u'Changeset with 0 action(s) ('))
+
+        self.assertEquals(
+            repr(cs),
+            '<Changeset 0 action(s) created=%r modified=%r>' % (
+                cs.created, cs.modified))
+
+        action = cs.newAction(
+            u'fake', FilePath(u'src'), FilePath(u'dst'), verify=False)
+
+        def _adapter(action):
+            return FakeAction()
+
+        cs.do(action, FakeOptions(), _adapter=_adapter)
+
+        self.assertTrue(
+            cs.asHumanly().startswith(
+                u'Changeset with 1 action(s) ('))
+
+        self.assertEquals(
+            repr(cs),
+            '<Changeset 1 action(s) created=%r modified=%r>' % (
+                cs.created, cs.modified))
+
+
+
+class ActionTests(TestCase):
+    """
+    Tests for L{renamer.history.Action}.
+    """
+    def setUp(self):
+        self.store = Store()
+        self.history = history.History(store=self.store)
+
+
+    def test_adaption(self):
+        """
+        Adapting a L{renamer.history.Action} object to
+        L{renamer.irenamer.IRenamingAction} results in an object implementing
+        C{IRenamingAction} that can perform forward and reverse actions.
+        """
+        cs = self.history.newChangeset()
+        action = cs.newAction(u'symlink', FilePath(u'src'), FilePath(u'dst'))
+        a = irenamer.IRenamingAction(action)
+        self.assertIdentical(type(a), SymlinkAction)
+        self.assertTrue(irenamer.IRenamingAction.providedBy(type(a)))
+
+
+    def test_representations(self):
+        """
+        L{renamer.history.Action.asHumanly} returns a human-readable and
+        accurate representation of an action.
+
+        L{renamer.history.Action.__repr__} returns a useful and accurate
+        representation of an action.
+        """
+        cs = self.history.newChangeset()
+        src = FilePath(u'src')
+        dst = FilePath(u'dst')
+        action = cs.newAction(u'fake', src, dst, verify=False)
+
+        self.assertTrue(
+            action.asHumanly().startswith(
+                u'Fake: %s => %s (' % (src.path, dst.path)))
+
+        self.assertEquals(
+            repr(action),
+            '<Action name=%r src=%r dst=%r created=%r>' % (
+                action.name, action.src, action.dst, action.created))

=== modified file 'renamer/test/test_plugin.py'
--- renamer/test/test_plugin.py	2010-10-01 23:22:38 +0000
+++ renamer/test/test_plugin.py	2010-10-24 17:31:17 +0000
@@ -15,7 +15,7 @@
         L{renamer.plugin.RenamerSubCommandMixin.decodeCommandLine} turns a byte
         string from the command line into a unicode string.
         """
-        decodeCommandLine = plugin.RenamerSubCommandMixin().decodeCommandLine
+        decodeCommandLine = plugin._CommandMixin().decodeCommandLine
 
         class MockFile(object):
             pass

=== modified file 'renamer/test/test_util.py'
--- renamer/test/test_util.py	2010-10-10 11:25:05 +0000
+++ renamer/test/test_util.py	2010-10-24 17:31:17 +0000
@@ -55,6 +55,59 @@
 
 
 
+class GlobTests(TestCase):
+    """
+    Tests for L{renamer.util.globArguments}.
+    """
+    def setUp(self):
+        self.path = FilePath(self.mktemp())
+        self.path.makedirs()
+
+        filenames = ['a', 'ab', '.a', 'a[b]c']
+        for fn in filenames:
+            self.path.child(fn).touch()
+
+
+    def assertGlob(self, expected, paths, **kw):
+        """
+        Assert that L{renamer.util.globArguments}C{(paths, **kw)} returns a
+        result equal to C{expected}.
+        """
+        paths = [self.path.child(p).path for p in paths]
+        res = util.globArguments(paths, **kw)
+        self.assertEquals(
+            sorted(expected), sorted(FilePath(v).basename() for v in res))
+
+
+    def test_glob(self):
+        """
+        Non-Windows globbing will expand an iterable of glob arguments
+        according to regular globbing rules.
+        """
+        values = [
+            (['a*'], ['a', 'a[b]c', 'ab']),
+            (['a?'], ['ab'])]
+        for paths, expected in values:
+            self.assertGlob(expected, paths)
+
+        self.assertGlob(
+            [], ['a[b]c'],
+            platform='notwin32')
+
+
+    def test_globWin32(self):
+        """
+        On Windows globbing will only occur if the glob argument is not the
+        name of an existing file, in which case the existing file name will be
+        the only result of globbing that argument.
+        """
+        self.assertGlob(
+            ['a', 'a[b]c'],
+            ['[ab]', 'a[b]c'],
+            platform='win32')
+
+
+
 class IThing(Interface):
     """
     Silly test interface.

=== modified file 'renamer/util.py'
--- renamer/util.py	2010-10-10 11:25:05 +0000
+++ renamer/util.py	2010-10-24 17:31:17 +0000
@@ -1,4 +1,8 @@
-import errno, os
+import errno
+import glob
+import itertools
+import os
+import sys
 from zope.interface import alsoProvides
 
 from twisted.internet.defer import DeferredList
@@ -73,3 +77,23 @@
         newcls = type.__new__(cls, name, bases, attrs)
         alsoProvides(newcls, *cls.providedInterfaces)
         return newcls
+
+
+
+def globArguments(args, platform=sys.platform, exists=os.path.exists):
+    """
+    Glob arguments.
+    """
+    def _iglobWin32(pathname):
+        if not exists(pathname):
+            return glob.iglob(pathname)
+        return [pathname]
+
+    def _glob(globbing):
+        return itertools.chain(
+            *itertools.imap(globbing, args))
+
+    globbing = glob.iglob
+    if platform == 'win32':
+        globbing = _iglobWin32
+    return _glob(globbing)

=== modified file 'setup.py'
--- setup.py	2010-10-01 12:43:32 +0000
+++ setup.py	2010-10-24 17:31:17 +0000
@@ -1,7 +1,17 @@
+import sys
 from epsilon.setuphelper import autosetup
 
 import renamer
 
+
+
+def scripts():
+    if sys.platform == 'win32':
+        yield 'bin/rn.cmd'
+    yield 'bin/rn'
+
+
+
 distobj = autosetup(
     name="Renamer",
     version=renamer.version.short(),
@@ -15,5 +25,4 @@
         "Programming Language :: Python",
         "Development Status :: 3 - Alpha",
         "Topic :: Utilities"],
-
-    scripts=['bin/rn'])
+    scripts=list(scripts()))