X-Git-Url: http://git.tremily.us/?p=hooke.git;a=blobdiff_plain;f=hooke%2Fcommand_stack.py;h=9b2dcd7ca9eae50d0bbeaac25db1e064393555a3;hp=3888a45e74efca10d1069b26833fecd6eff49fd3;hb=643629fa189f2bc8d05a6d9903ccd22637bc563d;hpb=608c372b4c9beb3f8c0cfc5a2889012827592d12 diff --git a/hooke/command_stack.py b/hooke/command_stack.py index 3888a45..9b2dcd7 100644 --- a/hooke/command_stack.py +++ b/hooke/command_stack.py @@ -20,38 +20,32 @@ executing stacks of :class:`~hooke.engine.CommandMessage`\s. """ +import os +import os.path + +import yaml + +from .engine import CommandMessage + class CommandStack (list): """Store a stack of commands. Examples -------- - >>> from .engine import CommandMessage - - Define two dummy commands for testing. - - >>> class CommandA (object): - ... name = 'CommandA' - >>> ca = CommandA() - >>> class CommandB (CommandA): - ... name = 'CommandB' - >>> cb = CommandB() + >>> c = CommandStack([CommandMessage('CommandA', {'param':'A'})]) + >>> c.append(CommandMessage('CommandB', {'param':'B'})) + >>> c.append(CommandMessage('CommandA', {'param':'C'})) + >>> c.append(CommandMessage('CommandB', {'param':'D'})) - Show off `CommandStack`\s functionality. - - >>> c = CommandStack([CommandMessage(ca, {'param':'A'})]) - >>> c.append(CommandMessage(cb, {'param':'B'})) - >>> c.append(CommandMessage(ca, {'param':'C'})) - >>> c.append(CommandMessage(cb, {'param':'D'})) - - Implement a dummy :meth:`_execute` for testing. + Implement a dummy :meth:`execute_command` for testing. - >>> def execute(hooke, command_message): + >>> def execute_cmd(hooke, command_message): ... cm = command_message - ... print 'EXECUTE', cm.command.name, cm.arguments - >>> c._execute = execute + ... print 'EXECUTE', cm.command, cm.arguments + >>> c.execute_command = execute_cmd - >>> c.execute() # doctest: +ELLIPSIS + >>> c.execute(hooke=None) # doctest: +ELLIPSIS EXECUTE CommandA {'param': 'A'} EXECUTE CommandB {'param': 'B'} EXECUTE CommandA {'param': 'C'} @@ -61,16 +55,36 @@ class CommandStack (list): If, for example, you are applying a set of commands to the current :class:`~hooke.curve.Curve`, you may only want to execute instances of :class:`~hooke.plugin.curve.CurveCommand`. Here we - only execute instances of `CommandB`. + only execute commands named `CommandB`. - >>> def filter(command_message): - ... return isinstance(command_message.command, CommandB) + >>> def filter(hooke, command_message): + ... return command_message.command == 'CommandB' >>> c.filter = filter - Apply the stack to the current curve - >>> c.execute() # doctest: +ELLIPSIS + Apply the stack to the current curve. + + >>> c.execute(hooke=None) # doctest: +ELLIPSIS EXECUTE CommandB {'param': 'B'} EXECUTE CommandB {'param': 'D'} + + Execute a new command and add it to the stack. + + >>> cm = CommandMessage('CommandC', {'param':'E'}) + >>> c.execute_command(hooke=None, command_message=cm) + EXECUTE CommandC {'param': 'E'} + >>> c.append(cm) + >>> print [repr(cm) for cm in c] # doctest: +NORMALIZE_WHITESPACE + ['', + '', + '', + '', + ''] + + There is also a convenience function for clearing the stack. + + >>> c.clear() + >>> print [repr(cm) for cm in c] + [] """ def execute(self, hooke): """Execute a stack of commands. @@ -80,14 +94,136 @@ class CommandStack (list): _execute, filter """ for command_message in self: - if self.filter(command_message) == True: - self._execute(hooke, command_message) + if self.filter(hooke, command_message) == True: + self.execute_command( + hooke=hooke, command_message=command_message) + + def filter(self, hooke, command_message): + """Return `True` to execute `command_message`, `False` otherwise. - def filter(self, command_message): - """Any commands in the stack that are not subclasses of - :class:`~hooke.plugin.curve.CurveCommand` are ignored. + The default implementation always returns `True`. """ return True - def _execute(self, hooke, command_message): - hooke.run_command(command_message.command, command_message.arguments) + def execute_command(self, hooke, command_message): + hooke.run_command(command=command_message.command, + arguments=command_message.arguments) + + def clear(self): + while len(self) > 0: + self.pop() + + +class FileCommandStack (CommandStack): + """A file-backed :class:`CommandStack`. + """ + version = '0.1' + + def __init__(self, *args, **kwargs): + super(FileCommandStack, self).__init__(*args, **kwargs) + self.name = None + self.path = None + + def set_path(self, path): + """Set the path (and possibly the name) of the command stack. + + Examples + -------- + >>> c = FileCommandStack([CommandMessage('CommandA', {'param':'A'})]) + + :attr:`name` is set only if it starts out equal to `None`. + >>> c.name == None + True + >>> c.set_path(os.path.join('path', 'to', 'my', 'command', 'stack')) + >>> c.path + 'path/to/my/command/stack' + >>> c.name + 'stack' + >>> c.set_path(os.path.join('another', 'path')) + >>> c.path + 'another/path' + >>> c.name + 'stack' + """ + if path != None: + self.path = path + if self.name == None: + self.name = os.path.basename(path) + + def save(self, path=None, makedirs=True): + """Saves the command stack to `path`. + """ + self.set_path(path) + dirname = os.path.dirname(self.path) + if makedirs == True and not os.path.isdir(dirname): + os.makedirs(dirname) + with open(self.path, 'w') as f: + f.write(self.flatten()) + + def load(self, path=None): + """Load a command stack from `path`. + """ + self.set_path(path) + with open(self.path, 'r') as f: + text = f.read() + self.from_string(text) + + def flatten(self): + """Create a string representation of the command stack. + + A playlist is a YAML document with the following syntax:: + + - arguments: {param: A} + command: CommandA + - arguments: {param: B, ...} + command: CommandB + ... + + Examples + -------- + >>> c = FileCommandStack([CommandMessage('CommandA', {'param':'A'})]) + >>> c.append(CommandMessage('CommandB', {'param':'B'})) + >>> c.append(CommandMessage('CommandA', {'param':'C'})) + >>> c.append(CommandMessage('CommandB', {'param':'D'})) + >>> print c.flatten() + - arguments: {param: A} + command: CommandA + - arguments: {param: B} + command: CommandB + - arguments: {param: C} + command: CommandA + - arguments: {param: D} + command: CommandB + + """ + return yaml.dump([{'command':cm.command,'arguments':cm.arguments} + for cm in self]) + + def from_string(self, string): + """Load a playlist from a string. + + .. warning:: This is *not safe* with untrusted input. + + Examples + -------- + + >>> string = '''- arguments: {param: A} + ... command: CommandA + ... - arguments: {param: B} + ... command: CommandB + ... - arguments: {param: C} + ... command: CommandA + ... - arguments: {param: D} + ... command: CommandB + ... ''' + >>> c = FileCommandStack() + >>> c.from_string(string) + >>> print [repr(cm) for cm in c] # doctest: +NORMALIZE_WHITESPACE + ['', + '', + '', + ''] + """ + for x in yaml.load(string): + self.append(CommandMessage(command=x['command'], + arguments=x['arguments']))