pmacs3/method/shell.py

import os, commands, re, sets, tempfile
from subprocess import Popen, PIPE, STDOUT

import buffer, default, dirutil, regex, util, window
from point import Point

from method import DATATYPES, Method, Argument

class Exec(Method):
    '''Execute a command in a shell and put the output in a new buffer'''
    args = [Argument('cmd', prompt="Exec: ", datatype='shell')]
    def _doit(self, w, path, cmd):
        if path:
            try:
                cmd = cmd % {'path': path}
            except:
                pass
        (status, output) = commands.getstatusoutput(cmd)
        self._display(w, output, status, cmd)

    def _display(self, w, data, status, cmd):
        bufname = '*%s*' % self.name.title()
        w.application.data_buffer(bufname, data, switch_to=True)
        w.set_error("Shell exited with %d" % status)
        
    def _execute(self, w, **vargs):
        if w.buffer.btype == 'dir':
            name = dirutil.resolve_name(w)
            path = dirutil.resolve_path(w)
            self._doit(w, path, vargs['cmd'])
            dirutil.find_name(w, name)
        elif hasattr(w.buffer, 'path'):
            path = w.buffer.path
            self._doit(w, path, vargs['cmd'])
        else:
            self._doit(w, None, vargs['cmd'])

class Pipe(Method):
    '''Pipe the buffer's contents through the command, and display the output in a new buffer'''
    args = [Argument('cmd', datatype="str", prompt="Command: ")]
    def _parse(self, w, **vargs):
        # return 3 things: prog name, cmd, and whether to use the shell
        m = regex.shell_command.match(vargs['cmd'])
        if m:
            prog = m.group(0)
            return (prog, vargs['cmd'], True)
        else:
            return (None, None, False)

    def _display(self, w, data, status, prog, cmd, shell):
        bufname = '*%s*' % self.name.title()
        w.application.data_buffer(bufname, data, switch_to=True)
        w.set_error("%s exited with status %d" % (prog, status))

    def _execute(self, w, **vargs):
        (prog, cmd, shell) = self._parse(w, **vargs)
        if prog is None or not cmd:
            return

        pipe = Popen(cmd, shell=shell, stdin=PIPE, stdout=PIPE, stderr=STDOUT)
        pid = pipe.pid

        indata = w.buffer.make_string()
        pipe.stdin.write(indata)
        pipe.stdin.close()

        outdata = pipe.stdout.read()
        status  = pipe.wait() >> 8

        self._display(w, outdata, status, prog, cmd, shell)

class Grep(Pipe):
    '''Grep the buffer's contents for instances of a pattern, and display them in a new buffer'''
    args = [Argument('pattern', datatype="str", prompt="Pattern: ")]
    def _parse(self, w, **vargs):
        return ('grep', ('grep', '-E', '-n', vargs['pattern']), False)
class Sed(Pipe):
    '''Push the buffer's contents through a sed expression'''
    args = [Argument('expression', datatype="str", prompt="Expression: ")]
    def _parse(self, w, **vargs):
        return ('grep', ('sed', '-r', '-e', vargs['expression']), False)