Merge lp:~renamer-developers/renamer/intents into lp:renamer

[Jonathan Jacobs]

Move hardcoded renaming functionality from the core to a more flexible system.

[lp:~renamer-developers/renamer/intents]

91. By Jonathan Jacobs on 2010-10-31

Merge trunk.

[Jonathan Jacobs (jjacobs)]

Conflicts between this branch and trunk have been resolved.

[lp:~renamer-developers/renamer/intents]

92. By Jonathan Jacobs on 2010-10-31

Fix option name typo.

93. By Jonathan Jacobs on 2010-11-10

Merge trunk.

94. By Jonathan Jacobs on 2010-11-10

Update documentation and examples to use the new intent API.

Unmerged revisions

94. By Jonathan Jacobs on 2010-11-10

Update documentation and examples to use the new intent API.

93. By Jonathan Jacobs on 2010-11-10

Merge trunk.

92. By Jonathan Jacobs on 2010-10-31

Fix option name typo.

91. By Jonathan Jacobs on 2010-10-31

Merge trunk.

90. By Jonathan Jacobs on 2010-10-29

Fix bugs exposed by tests.

89. By Jonathan Jacobs on 2010-10-29

Tests for renamer.intents.

88. By Jonathan Jacobs on 2010-10-29

Tweaks.

87. By Jonathan Jacobs on 2010-10-29

Implement command intents which are returned from ICommand.process and acted on by the core.

Intents allow commands to specify custom behaviour (such as performing custom actions) and reuse existing behaviour, as well as making the Renamer core cleaner.

=== modified file 'docs/code/plugins_command.py'
--- docs/code/plugins_command.py	2010-10-24 18:57:10 +0000
+++ docs/code/plugins_command.py	2010-11-10 10:12:38 +0000
@@ -1,25 +1,24 @@
-import os
 import string
 import time
 
+from renamer.intents import Rename
+from renamer.errors import PluginError
 from renamer.plugin import RenamingCommand
-from renamer.errors import PluginError
 
 
 class ReadableTimestamps(RenamingCommand):
     # The name of our command, as it will be used from the command-line.
     name = 'timestamp'
 
+
     # A brief description of the command's purpose, displayed in --help output.
     description = 'Rename files with POSIX timestamps to human-readble times.'
 
+
     # Command-line parameters we support.
     optParameters = [
         ('format', 'f', '%Y-%m-%d %H-%M-%S', 'strftime format.')]
 
-    # The default name template to use if no name template is specified via the
-    # command-line or configuration file.
-    defaultNameTemplate = string.Template('$time')
 
     # IRenamerCommand
 
@@ -38,5 +37,5 @@
             # Convert and format the timestamp according to the "format"
             # command-line parameter.
             t = time.localtime(timestamp)
-            return {
-                'time': time.strftime(self['format'], t)}
+            name = time.strftime(self['format'], t)
+            return Rename({}, arg, nameTemplate=name)

=== modified file 'docs/plugins.rst'
--- docs/plugins.rst	2010-10-24 18:57:10 +0000
+++ docs/plugins.rst	2010-11-10 10:12:38 +0000
@@ -43,11 +43,16 @@
 invoking your command and performing the actual file renaming.
 
 At the heart of a renaming command is ``processArgument`` which accepts one
-argument and returns a Python dictionary. That dictionary is then used to
-perform `template substitution`_ on the ``name`` and ``prefix`` command-line
-options (or, if they're not given, command-specific defaults.) This process of
-calling ``processArgument`` is repeated for each argument given, letting your
-command process one argument at a time.
+argument and returns an intent (something implementing ``ICommandIntent``) to
+be acted on by the core, which will ultimately perform some actions and produce
+an end result for the command.  This process of calling ``processArgument`` is
+repeated for each argument, letting your command process one argument at a
+time.
+
+The ``Rename`` intent, probably the most common intent in Renamer, performs
+`template substitution`_ on the ``name`` and ``prefix`` command-line options
+(or, if they're not given, command-specific defaults) before finally renaming
+the argument.
 
 .. _template substitution:
     http://docs.python.org/library/string.html#template-strings
@@ -58,8 +63,8 @@
 
 If your command performs a long-running task, such as fetching data from a web
 server, you can return a `Deferred`_ from ``processArgument`` that should
-ultimately return with a Python dictionary to be used in assembling the
-destination filename.
+ultimately return an ``ICommandIntent`` provider that will be acted on by the
+Renamer core.
 
 .. _Deferred:
     http://twistedmatrix.com/documents/current/core/howto/deferredindepth.html

=== modified file 'renamer/application.py'
--- renamer/application.py	2010-11-01 08:48:08 +0000
+++ renamer/application.py	2010-11-10 10:12:38 +0000
@@ -1,7 +1,6 @@
 """
 Renamer application logic.
 """
-import itertools
 import os
 import string
 import sys
@@ -13,7 +12,7 @@
 from twisted.python.filepath import FilePath
 
 from renamer import config, logging, plugin, util, version
-from renamer.irenamer import IRenamingCommand
+from renamer.irenamer import ICommandIntent
 from renamer.history import History
 
 
@@ -40,9 +39,7 @@
 
     @property
     def subCommands(self):
-        commands = itertools.chain(
-            plugin.getRenamingCommands(), plugin.getCommands())
-        for plg in commands:
+        for plg in plugin.getCommands():
             try:
                 yield (
                     plg.name,
@@ -57,6 +54,7 @@
         super(Options, self).__init__()
         self['verbosity'] = 1
         self.config = config
+        self.args = [None]
 
 
     @property
@@ -172,35 +170,9 @@
         return command
 
 
-    def performRename(self, dst, src):
-        """
-        Perform a file rename.
-        """
-        if self.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 self.options['link-dst']:
-            self.changeset.do(
-                self.changeset.newAction(u'symlink', src, dst),
-                self.options)
-        else:
-            self.changeset.do(
-                self.changeset.newAction(u'move', src, dst),
-                self.options)
-            if self.options['link-src']:
-                self.changeset.do(
-                    self.changeset.newAction(u'symlink', dst, src),
-                    self.options)
-
-
     def runCommand(self, command):
         """
-        Run a generic command.
+        Run a command.
         """
         logging.msg(
             'Using command "%s"' % (command.name,),
@@ -211,33 +183,46 @@
         return defer.maybeDeferred(command.process, self, self.options)
 
 
-    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()
+    def _actOnIntent(self, intent, changeset):
+        """
+        Act on a L{renamer.irenamer.ICommandIntent}.
+        """
+        if intent is None:
+            return
+
+        logging.msg('Intent: %s' % (intent.asHumanly(self.options),),
+            verbosity=2)
+        if self.options['no-act']:
+            return
+        return intent.act(changeset, self.command, self.options)
+
+
+    def _processOne(self, src, changeset):
+        """
+        Process a single command argument and act on the resulting
+        L{renamer.irenamer.ICommandIntent}.
+        """
+        self.currentArgument = src
+        d = self.runCommand(self.command)
+        d.addCallback(ICommandIntent, None)
+        d.addCallback(self._actOnIntent, changeset)
+        return d
+
+
+    def run(self):
+        """
+        Begin processing commands.
+        """
         logging.msg(
             'Running, doing at most %d concurrent operations' % (
                 self.options['concurrency'],),
             verbosity=3)
-        return util.parallel(
-            self.args, self.options['concurrency'], _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)
+        changeset = self.history.newChangeset()
+        d = util.parallel(
+            self.options.args,
+            self.options['concurrency'],
+            self._processOne,
+            changeset)
         d.addCallback(self.exit)
         return d
 
@@ -246,6 +231,6 @@
         """
         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.
+        # We can safely do this even with "no-act", since if 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 22:37:54 +0000
+++ renamer/errors.py	2010-11-10 10:12:38 +0000
@@ -23,3 +23,10 @@
     """
     A destination file already exists.
     """
+
+
+
+class IntentError(ValueError):
+    """
+    An errror occured while acting on a L{renamer.irenamer.ICommandIntent}.
+    """

=== added file 'renamer/intents.py'
--- renamer/intents.py	1970-01-01 00:00:00 +0000
+++ renamer/intents.py	2010-11-10 10:12:38 +0000
@@ -0,0 +1,146 @@
+import os
+import string
+from zope.interface import implements
+
+from twisted.python.filepath import FilePath
+
+from renamer import errors, logging
+from renamer.irenamer import ICommandIntent
+
+
+
+class Rename(object):
+    """
+    Intent to rename a file.
+
+    Template substitution is applied to filenames and prefixes.
+
+    @type mapping: C{dict} mapping C{str} to C{unicode}
+    @ivar mapping: Mapping of template variables, used for template
+        substitution.
+
+    @type src: L{twisted.python.filepath.FilePath}
+    @ivar src: Source path.
+
+    @type prefixTemplate: C{string.Template}
+    @ivar prefixTemplate: String template for the prefix format to use if one
+        is not supplied in the configuration. Defaults to the directory path of
+        L{src}.
+
+    @type nameTemplate: C{string.Template}
+    @ivar nameTemplate: String template for the name format to use if one is
+        not supplied in the configuration.
+    """
+    implements(ICommandIntent)
+
+
+    def __init__(self, mapping, src, prefixTemplate=None, nameTemplate=None):
+        self.mapping = mapping
+        self.src = src
+        if prefixTemplate is None:
+            prefixTemplate = self.src.dirname()
+        if isinstance(prefixTemplate, (unicode, str)):
+            prefixTemplate = string.Template(prefixTemplate)
+        self.prefixTemplate = prefixTemplate
+
+        if isinstance(nameTemplate, (unicode, str)):
+            nameTemplate = string.Template(nameTemplate)
+        self.nameTemplate = nameTemplate
+
+
+    def getDestination(self, options):
+        """
+        Get the destination path.
+
+        Substitution of L{mapping} into the C{'prefix'} command-line option
+        (defaulting to L{prefixTemplate}) and the C{'name'} command-line option
+        (defaulting to L{nameTemplate}) is performed.
+
+        @type options: L{twisted.python.usage.Options}
+
+        @rtype:  L{twisted.python.filepath.FilePath}
+        @return: Destination path.
+        """
+        prefixTemplate = options['prefix']
+        if prefixTemplate is None:
+            prefixTemplate = self.prefixTemplate
+
+        prefix = os.path.expanduser(
+            prefixTemplate.safe_substitute(self.mapping))
+
+        ext = self.src.splitext()[-1]
+
+        nameTemplate = options['name']
+        if nameTemplate is None:
+            nameTemplate = self.nameTemplate
+
+        if nameTemplate is None:
+            raise errors.IntentError('Missing name template')
+
+        filename = nameTemplate.safe_substitute(self.mapping)
+        logging.msg(
+            'Building filename: prefix=%r  name=%r  mapping=%r' % (
+                prefixTemplate.template, nameTemplate.template, self.mapping),
+            verbosity=3)
+        return FilePath(prefix).child(filename).siblingExtension(ext)
+
+
+    # ICommandIntent
+
+    def act(self, changeset, command, options):
+        src = self.src
+        dst = self.getDestination(options)
+
+        if options['link-dst']:
+            changeset.do(
+                changeset.newAction(u'symlink', src, dst),
+                options)
+        else:
+            changeset.do(
+                changeset.newAction(u'move', src, dst),
+                options)
+            if options['link-src']:
+                changeset.do(
+                    changeset.newAction(u'symlink', dst, src),
+                    options)
+
+
+    def asHumanly(self, options):
+        src = self.src.path
+        dst = self.getDestination(options).path
+        return u'%s: %s => %s' % (
+            type(self).__name__, src, dst)
+
+
+
+class Undo(object):
+    """
+    Intent to undo history action.
+
+    @type actions: C{list} of L{renamer.history.Action}
+    """
+    implements(ICommandIntent)
+
+
+    def __init__(self, actions):
+        self.actions = list(actions)
+
+
+    # ICommandIntent
+
+    def act(self, changeset, command, options):
+        for action in self.actions:
+            cs = action.changeset
+
+            logging.msg('Undo: %s' % (action.asHumanly()), verbosity=3)
+            try:
+                cs.undo(action, options)
+            except OSError, e:
+                if not command['ignore-errors']:
+                    raise e
+                logging.msg('Ignoring %r' % (e,), verbosity=3)
+
+
+    def asHumanly(self, options):
+        return u'%s: %r' % (
+            type(self).__name__, self.actions)

=== modified file 'renamer/irenamer.py'
--- renamer/irenamer.py	2010-10-20 18:08:59 +0000
+++ renamer/irenamer.py	2010-11-10 10:12:38 +0000
@@ -23,6 +23,9 @@
         @type renamer: L{renamer.application.Renamer}
 
         @type options: C{dict}
+
+        @rtype:  L{renamer.irenamer.ICommandIntent}
+        @return: Intent to act on; or C{None}.
         """
 
 
@@ -31,24 +34,12 @@
     """
     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.
-    """)
-
-
     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.
+        @rtype:  L{renamer.irenamer.ICommandIntent}
+        @return: Intent to act on; or C{None}.
         """
 
 
@@ -81,3 +72,36 @@
 
         @type options: C{dict}
         """
+
+
+
+class ICommandIntent(Interface):
+    """
+    A command intent that can be acted on.
+
+    Intents to be acted on are returned from
+    L{renamer.irenamer.ICommand.process}.
+    """
+    def act(changeset, command, options):
+        """
+        Act on an intent.
+
+        @type  changeset: L{renamer.history.Changeset}
+        @param changeset: Changeset this intent will recorded in, any undo-able
+            actions taken should be recorded in this changeset.
+
+        @type  command: L{renamer.irenamer.ICommand}
+        @param command: Command being executed.
+
+        @type  options: L{dict}
+        @param options: Configuration options.
+        """
+
+
+    def asHumanly(options):
+        """
+        Construct a human readable representation of the intent.
+
+        @type  options: L{dict}
+        @param options: Configuration options.
+        """

=== modified file 'renamer/plugin.py'
--- renamer/plugin.py	2010-10-20 18:08:59 +0000
+++ renamer/plugin.py	2010-11-10 10:12:38 +0000
@@ -1,12 +1,9 @@
-import os
-import string
 import sys
-from zope.interface import noLongerProvides
+from zope.interface import implements, noLongerProvides
 
 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 errors, logging, plugins
 from renamer.irenamer import ICommand, IRenamingCommand, IRenamingAction
@@ -22,14 +19,6 @@
 
 
 
-def getRenamingCommands():
-    """
-    Get all available L{renamer.irenamer.IRenamingCommand}s.
-    """
-    return getPlugins(IRenamingCommand, plugins)
-
-
-
 def getActions():
     """
     Get all available L{renamer.irenamer.IRenamingAction}s.
@@ -102,74 +91,18 @@
 
 
 
-class RenamingCommandMeta(InterfaceProvidingMetaclass):
-    providedInterfaces = [IPlugin, IRenamingCommand]
-
-
-
-class RenamingCommand(_CommandMixin, usage.Options):
+class RenamingCommand(Command):
     """
     Top-level renaming command.
 
     This command will display in the main help listing.
     """
-    __metaclass__ = RenamingCommandMeta
+    implements(IRenamingCommand)
 
 
     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: C{dict}
-
-        @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.
@@ -183,9 +116,7 @@
         arg = renamer.currentArgument
         logging.msg('Processing "%s"' % (arg.path,),
                     verbosity=3)
-        d = defer.maybeDeferred(self.processArgument, arg)
-        d.addCallback(self.buildDestination, options, arg)
-        return d
+        return defer.maybeDeferred(self.processArgument, arg)
 
 
     # IRenamingCommand
@@ -195,7 +126,7 @@
             'RenamingCommands must implement "processArgument"')
 
 noLongerProvides(RenamingCommand, IPlugin)
-noLongerProvides(RenamingCommand, IRenamingCommand)
+noLongerProvides(RenamingCommand, ICommand)
 
 
 

=== modified file 'renamer/plugins/audio.py'
--- renamer/plugins/audio.py	2010-10-15 08:51:27 +0000
+++ renamer/plugins/audio.py	2010-11-10 10:12:38 +0000
@@ -1,4 +1,3 @@
-import string
 from functools import partial
 
 try:
@@ -7,7 +6,7 @@
 except ImportError:
     mutagen = None
 
-from renamer import logging
+from renamer import intents, logging
 from renamer.plugin import RenamingCommand
 from renamer.errors import PluginError
 
@@ -29,12 +28,10 @@
     """
 
 
-    defaultPrefixTemplate = string.Template(
-        '${artist}/${album} (${date})')
-
-
-    defaultNameTemplate = string.Template(
-        '${tracknumber}. ${title}')
+    defaultPrefixTemplate = '${artist}/${album} (${date})'
+
+
+    defaultNameTemplate = '${tracknumber}. ${title}'
 
 
     def postOptions(self):
@@ -83,13 +80,18 @@
         return int(tracknumber)
 
 
-    # IRenamerCommand
+    # IRenamingCommand
 
     def processArgument(self, arg):
         T = partial(self.getTag, arg)
-        return dict(
+        mapping = 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'])))
+        return intents.Rename(
+            mapping,
+            arg,
+            prefixTemplate=self.defaultPrefixTemplate,
+            nameTemplate=self.defaultNameTemplate)

=== modified file 'renamer/plugins/tv.py'
--- renamer/plugins/tv.py	2010-10-27 00:48:13 +0000
+++ renamer/plugins/tv.py	2010-11-10 10:12:38 +0000
@@ -1,4 +1,3 @@
-import string
 import urllib
 
 try:
@@ -11,7 +10,7 @@
 
 from twisted.web.client import getPage
 
-from renamer import logging
+from renamer import intents, logging
 from renamer.plugin import RenamingCommand
 from renamer.errors import PluginError
 try:
@@ -92,8 +91,7 @@
     """
 
 
-    defaultNameTemplate = string.Template(
-        '$series [${season}x${padded_episode}] - $title')
+    defaultNameTemplate = '$series [${season}x${padded_episode}] - $title'
 
 
     optParameters = [
@@ -190,11 +188,13 @@
         return fetcher(url).addCallback(self.extractMetadata)
 
 
-    # IRenamerCommand
+    # IRenamingCommand
 
     def processArgument(self, arg):
         seriesName, season, episode = self.extractParts(
             arg.basename(), overrides=self)
         d = self.lookupMetadata(seriesName, season, episode)
         d.addCallback(self.buildMapping)
+        d.addCallback(
+            intents.Rename, arg, nameTemplate=self.defaultNameTemplate)
         return d

=== modified file 'renamer/plugins/undo.py'
--- renamer/plugins/undo.py	2010-10-31 19:34:03 +0000
+++ renamer/plugins/undo.py	2010-11-10 10:12:38 +0000
@@ -1,6 +1,6 @@
 from twisted.python import usage
 
-from renamer import logging
+from renamer import intents, logging
 from renamer.history import Action, Changeset
 from renamer.plugin import Command, SubCommand
 
@@ -25,55 +25,36 @@
 
 
 
-class _UndoMixin(object):
-    optFlags = [
-        ('ignore-errors', None, 'Do not stop the process when encountering OS errors.')]
-
-
-    def undoActions(self, options, changeset, actions):
-        """
-        Undo specific actions from a changeset.
-        """
-        for action in actions:
-            msg = 'Simulating undo'
-            if not options['no-act']:
-                msg = 'Undo'
-
-            logging.msg('%s: %s' % (msg, action.asHumanly()), verbosity=3)
-            if not options['no-act']:
-                try:
-                    changeset.undo(action, options)
-                except OSError, e:
-                    if not self['ignore-errors']:
-                        raise e
-                    logging.msg('Ignoring %r' % (e,), verbosity=3)
-
-
-
-class UndoAction(SubCommand, _UndoMixin):
+class UndoAction(SubCommand):
     name = 'action'
 
 
-    synopsis = '[options] <actionID>'
+    synopsis = '[options] <actionID> [actionID ...]'
 
 
     longdesc = """
-    Undo a single action from a changeset. Consult "undo list" for action
-    identifiers.
+    Undo individual actions. Consult "undo list" for action identifiers.
     """
 
 
-    def parseArgs(self,  action):
-        self['action'] = action
-
-
-    def process(self, renamer, options):
-        action = getItem(renamer.store, self['action'], Action)
-        self.undoActions(options, action.changeset, [action])
-
-
-
-class UndoChangeset(SubCommand, _UndoMixin):
+    optFlags = [
+        ('ignore-errors', None,
+         'Do not stop the process when encountering OS errors')]
+
+
+    def parseArgs(self, action, *actions):
+        self['actions'] = (action,) + actions
+
+
+    def process(self, renamer):
+        actions = [
+            getItem(renamer.store, identifier, Action)
+            for identifier in self['actions']]
+        return intents.Undo(actions)
+
+
+
+class UndoChangeset(SubCommand):
     name = 'changeset'
 
 
@@ -85,6 +66,11 @@
     """
 
 
+    optFlags = [
+        ('ignore-errors', None,
+         'Do not stop the process when encountering OS errors')]
+
+
     def parseArgs(self, changeset):
         self['changeset'] = changeset
 
@@ -93,8 +79,8 @@
         changeset = getItem(renamer.store, self['changeset'], Changeset)
         logging.msg('Undoing: %s' % (changeset.asHumanly(),),
                     verbosity=3)
-        actions = list(changeset.getActions())
-        self.undoActions(options, changeset, reversed(actions))
+        actions = reversed(list(changeset.getActions()))
+        return intents.Undo(actions)
 
 
 

=== added file 'renamer/test/test_intents.py'
--- renamer/test/test_intents.py	1970-01-01 00:00:00 +0000
+++ renamer/test/test_intents.py	2010-11-10 10:12:38 +0000
@@ -0,0 +1,263 @@
+import os
+import string
+
+from twisted.python.filepath import FilePath
+from twisted.trial.unittest import TestCase
+
+from axiom.store import Store
+
+from renamer import application, errors, history, intents
+
+
+
+class RenameTests(TestCase):
+    """
+    Tests for L{renamer.intents.Rename}.
+    """
+    def setUp(self):
+        self.store = Store()
+        self.src = FilePath(u'src.ext')
+        self.history = history.History(store=self.store)
+
+
+    def act(self, options):
+        """
+        Act on a L{renamer.intents.Rename} intent.
+        """
+        cs = self.history.newChangeset()
+
+        path = FilePath(self.mktemp())
+        path.makedirs()
+
+        src = path.child(u'src')
+        src.touch()
+        self.assertTrue(src.exists())
+        self.assertTrue(src.isfile())
+
+        dst = src.sibling(u'dst')
+        self.assertFalse(dst.exists())
+
+        i = intents.Rename({}, src)
+        options['name'] = string.Template(u'dst')
+        i.act(cs, {}, options)
+        src.restat(False)
+        dst.restat(False)
+
+        return src, dst
+
+
+    def test_asHumanly(self):
+        """
+        L{renamer.intents.Rename.asHumanly} produces accurate human-readable
+        output.
+        """
+        i = intents.Rename({}, self.src)
+        dst = self.src.sibling(u'dst.ext')
+        options = dict(prefix=None, name=string.Template(u'dst'))
+        self.assertEquals(
+            i.asHumanly(options),
+            u'Rename: %s => %s' % (self.src.path, dst.path))
+
+
+    def test_act(self):
+        """
+        Acting on a L{renamer.intents.Rename} intent renames a file.
+        """
+        options = application.Options(None)
+
+        src, dst = self.act(options)
+        self.assertFalse(src.exists())
+        self.assertTrue(dst.exists())
+        self.assertTrue(dst.isfile())
+
+
+    def test_actSourceLink(self):
+        """
+        Acting on a L{renamer.intents.Rename} intent with the C{'link-src'}
+        configuration option renames a file and creates a symlink at the source
+        to the new path.
+        """
+        options = application.Options(None)
+        options['link-src'] = True
+
+        src, dst = self.act(options)
+        self.assertTrue(src.exists())
+        self.assertTrue(src.islink())
+        self.assertTrue(dst.exists())
+        self.assertTrue(dst.isfile())
+        link = os.readlink(src.path)
+        self.assertEquals(link, dst.path)
+
+
+    def test_actDestinationLink(self):
+        """
+        Acting on a L{renamer.intents.Rename} intent with the C{'link-dst'}
+        configuration option leaves the file inplace and creates a symlink at
+        the destination to the original path.
+        """
+        options = application.Options(None)
+        options['link-dst'] = True
+
+        src, dst = self.act(options)
+        self.assertTrue(src.exists())
+        self.assertTrue(src.isfile())
+        self.assertTrue(dst.exists())
+        self.assertTrue(dst.islink())
+        link = os.readlink(dst.path)
+        self.assertEquals(link, src.path)
+
+
+    def test_getDestinationErrors(self):
+        """
+        L{renamer.intents.Rename.getDestination} raises
+        L{renamer.errors.IntentError} if not enough information is specified to
+        build the destination path.
+        """
+        options = dict(prefix=None, name=None)
+        i = intents.Rename({}, self.src)
+        self.assertRaises(errors.IntentError, i.getDestination, options)
+
+
+    def test_getDestinationDefaults(self):
+        """
+        L{renamer.intents.Rename.getDestination} builds a destination path from
+        mapping and template data.
+        """
+        i = intents.Rename({}, self.src)
+        options = dict(prefix=None, name=string.Template(u'dst'))
+        self.assertEquals(
+            i.getDestination(options),
+            self.src.sibling(u'dst.ext'))
+
+
+    def test_getDestination(self):
+        """
+        L{renamer.intents.Rename.getDestination} builds a destination path from
+        mapping and template data.
+        """
+        options = dict(prefix=None, name=string.Template(u'dst'))
+
+        i = intents.Rename({}, self.src, prefixTemplate=u'foo')
+        self.assertEquals(
+            i.getDestination(options),
+            self.src.sibling(u'foo').child(u'dst.ext'))
+
+        i = intents.Rename({}, self.src, prefixTemplate=u'~/foo')
+        self.assertEquals(
+            i.getDestination(options),
+            FilePath(os.path.expanduser('~')).child(u'foo').child(u'dst.ext'))
+
+        i = intents.Rename(
+            dict(var=u'bar'),
+            self.src,
+            prefixTemplate=string.Template(u'$var/foo'))
+        self.assertEquals(
+            i.getDestination(options),
+            self.src.sibling(u'bar').child(u'foo').child(u'dst.ext'))
+
+        options = dict(prefix=None, name=None)
+        i = intents.Rename(
+            dict(var=u'bar'),
+            self.src,
+            nameTemplate=string.Template(u'$var'))
+        self.assertEquals(
+            i.getDestination(options),
+            self.src.sibling(u'bar.ext'))
+
+        i = intents.Rename(
+            {}, self.src, prefixTemplate=u'foo', nameTemplate=u'name')
+        self.assertEquals(
+            i.getDestination(options),
+            self.src.sibling(u'foo').child(u'name.ext'))
+
+
+
+class UndoTests(TestCase):
+    """
+    Tests for L{renamer.intents.Undo}.
+    """
+    def setUp(self):
+        path = FilePath(self.mktemp())
+        path.makedirs()
+
+        self.src = path.child(u'src')
+        self.dst = self.src.sibling(u'dst')
+        self.dst.touch()
+
+        self.store = Store()
+        self.history = history.History(store=self.store)
+        self.changeset = self.history.newChangeset()
+        action = self.changeset.newAction(u'move', self.src, self.dst)
+        action.changeset = self.changeset
+        self.history.pruneChangesets()
+        self.options = application.Options(None)
+
+
+    def getActions(self):
+        """
+        Get L{renamer.history.Action}s in the changeset.
+        """
+        return list(self.changeset.getActions())
+
+
+    def makeIntent(self):
+        """
+        Make a new L{renamer.intents.Undo} intent.
+        """
+        actions = self.getActions()
+        self.assertEquals(len(actions), 1)
+        self.assertFalse(self.src.exists())
+        self.assertTrue(self.dst.exists())
+        return intents.Undo(actions)
+
+
+    def test_asHumanly(self):
+        """
+        L{renamer.intents.Undo.asHumanly} produces accurate human-readable
+        output.
+        """
+        i = self.makeIntent()
+        self.assertEquals(
+            i.asHumanly({}),
+            u'Undo: %r' % (self.getActions(),))
+
+
+    def test_act(self):
+        """
+        Acting on a L{renamer.intents.Undo} intent undoes the specified
+        actions.
+        """
+        i = self.makeIntent()
+        command = {'ignore-errors': False}
+        i.act(self.history.newChangeset(), command, self.options)
+        self.assertEquals(len(self.getActions()), 0)
+        self.src.restat(False)
+        self.assertTrue(self.src.exists())
+        self.dst.restat(False)
+        self.assertFalse(self.dst.exists())
+
+
+    def test_actOSError(self):
+        """
+        L{renamer.intents.Undo.act} re-raises C{OSError}.
+        """
+        i = self.makeIntent()
+        # Remove the file we are supposed to operate on.
+        self.dst.remove()
+        command = {'ignore-errors': False}
+        self.assertRaises(OSError,
+            i.act, self.history.newChangeset(), command, self.options)
+        self.assertEquals(len(self.getActions()), 1)
+
+
+    def test_actIgnoreErrors(self):
+        """
+        L{renamer.intents.Undo.act} ignores C{OSError} if the
+        C{'ignore-errors'} configuration option is given.
+        """
+        i = self.makeIntent()
+        # Remove the file we are supposed to operate on.
+        self.dst.remove()
+        command = {'ignore-errors': True}
+        i.act(self.history.newChangeset(), command, self.options)
+        self.assertEquals(len(self.getActions()), 1)