# -*-Mode:python-*-

import os
import tempfile
import sys
import subprocess
import webbrowser
import urllib
import threading
import logging
from StringIO import StringIO

def cmd_menu(ensoapi):
    import AppKit
    import Foundation

    app = AppKit.NSApplication.sharedApplication()

    mainMenu = AppKit.NSMenu.alloc().initWithTitle_("Main")
    ensoMenu = AppKit.NSMenu.alloc().initWithTitle_("Boogy")

    item = AppKit.NSMenuItem.alloc().init()
    item.setTitle_("Boogy")
    item.setSubmenu_(ensoMenu)
    mainMenu.insertItem_atIndex_(item, 0)

    app.setMainMenu_(mainMenu)
    app.setServicesMenu_(ensoMenu)

    app.registerServicesMenuSendTypes_returnTypes_(
        [AppKit.NSStringPboardType],
        []
        )

    ensoapi.display_message(str(app.mainMenu()))

def cmd_define(ensoapi):
    import AppKit

    serviceName = "Look Up in Dictionary"

    text = ensoapi.get_selection().get("text", "")

    pb = AppKit.NSPasteboard.pasteboardWithName_("EnsoServiceContent")

    pb.declareTypes_owner_( [AppKit.NSStringPboardType], None )

    try:
        if not pb.setString_forType_( text, AppKit.NSStringPboardType ):
            raise Exception( "Failed to set pasteboard data." )

        if not AppKit.NSPerformService( serviceName, pb ):
            raise Exception( "Failed to perform service." )
    finally:
        pass

def cmd_impersonate(ensoapi):
    from xpcom import components

    class MyEventHandler:
        _com_interfaces_ = components.interfaces.nsIDOMEventListener

        def __init__(self, corpus, author):
            from nltk.probability import ConditionalFreqDist

            cfd = ConditionalFreqDist()
            prev_word = None
            for word in corpus.words():
                cfd[prev_word].inc(word)
                prev_word = word

            self._cfd = cfd
            self._author = author
            self._last_word = None

        def handleEvent(self, event):
            text = event.target.value[:event.target.selectionStart]
            words = text.split()
            if words and text[-1] == " ":
                last_word = words[-1]
                if last_word == self._last_word:
                    return
                self._last_word = last_word

                #sorted = self._cfd[last_word].sorted()
                suggestions = self._cfd[last_word].samples()
                suggestions.sort(key=len, reverse=True)
                suggestions = [sugg for sugg in suggestions
                               if len(sugg) > 3]

#                 if suggestions:
#                     import random
#                     suggestion = random.choice(suggestions)
#                     cursor = event.target.selectionStart
#                     event.target.value = event.target.value[:cursor] + suggestion + " " + event.target.value[cursor:]
#                     cursor += len(suggestion) + 1
#                     event.target.setSelectionRange(cursor, cursor)

#                 suggestions = None
                if suggestions:
                    cc = components.classes
                    asvc = cc["@mozilla.org/alerts-service;1"].getService(
                        components.interfaces.nsIAlertsService
                        )
                    asvc.showAlertNotification(
                        "http://www.mozilla.com/favicon.ico",
                        "%s would say..." % self._author,
                        ", ".join(suggestions[:10]),
                        False,
                        None,
                        None,
                        None,
                        )

    element = ensoapi.get_selection()["dom.element"]

    #from nltk.corpus import gutenberg

    #corpus, author = (gutenberg, "Project Gutenberg")
    from nltk.corpus.reader.plaintext import PlaintextCorpusReader

    corpus = PlaintextCorpusReader(
        os.getenv("HOME"),
        ["argon.txt"]
        )
    author = "Jim Theis"

    element.addEventListener(
        "keyup",
         MyEventHandler(corpus, author),
         False
         )

def cmd_extemporize(ensoapi):
    element = ensoapi.get_selection().get("dom.element")

    text = ""
    if element:
        text = element.value
        words = text.split()
        if words:
            from nltk.corpus.reader.plaintext import PlaintextCorpusReader

            corpus = PlaintextCorpusReader(
                os.getenv("HOME"),
                ["argon.txt"]
                )

            from nltk.probability import ConditionalFreqDist
            import random

            cfd = ConditionalFreqDist()
            prev_word = None
            for word in corpus.words():
                cfd[prev_word].inc(word)
                prev_word = word

            last_word = words[-1]
            new_words = []
            for i in range(10):
                potentials = cfd[last_word].samples()
                if potentials:
                    next_word = random.choice(potentials)
                else:
                    next_word = "Grignr"
                new_words.append(next_word)
                last_word = next_word
            string = ""
            for word in new_words:
                if len(word) == 1 and not word.isalpha():
                    string += "%s" % word
                else:
                    string += " %s" % word

            element.value = text + string

def getFuelApplication():
    from xpcom import components
    fuel_cls = components.classes["@mozilla.org/fuel/application;1"]
    fuel_abs = fuel_cls.createInstance()
    fuel_if = components.interfaces.fuelIApplication
    return fuel_abs.queryInterface(fuel_if)

def getXpcomObjInfo(thing):
    thing._build_all_supported_interfaces_()
    lines = []
    for iname in thing._interface_names_:
        methods = []
        properties = []
        for mname in thing._interface_names_[iname]._method_infos_:
            if mname != "QueryInterface":
                methods.append( "%s()" % mname )
        for pname in thing._interface_names_[iname]._property_getters_:
            properties.append( "%s" % pname )
        lines.append("%s:" % iname)
        if methods:
            lines.extend(["  METHODS: %s" % ", ".join(methods)])
        if properties:
            lines.extend(["  PROPERTIES: %s" % ", ".join(properties)])
    return "\n\n".join(lines)

def cmd_info(ensoapi):
    thing = getFuelApplication()
    ensoapi.set_selection( {"text" : getXpcomObjInfo(thing)} )

def cmd_highlight(ensoapi):
    """
    Highlights your current selection.
    """

    window = ensoapi.get_selection()["dom.window"]
    document = window.document
    sel = window.getSelection()
    if sel.rangeCount >= 1:
        range = sel.getRangeAt(0)
        newNode = document.createElement("span")
        newNode.style.background = "yellow"
        range.surroundContents(newNode)

def cmd_count_lines(ensoapi):
    seldict = ensoapi.get_selection()
    ensoapi.display_message( "Selection is %s lines." % 
                             len(seldict.get("text","").splitlines()) )

def _get_filelike_timestamp():
    import time

    return time.strftime("%Y%m%d%H%M%S")

def _get_clipboard_img_datafile():
    import AppKit

    pb = AppKit.NSPasteboard.generalPasteboard()
    if pb.availableTypeFromArray_([AppKit.NSTIFFPboardType]):
        bytes = pb.dataForType_(AppKit.NSTIFFPboardType).bytes()
        datafile = StringIO(str(bytes))
        return datafile
    else:
        return None

def image_command(func):
    def wrapper(ensoapi):
        import Image

        datafile = _get_clipboard_img_datafile()
        if datafile:
            img = Image.open(datafile)
            return func(ensoapi, img)
        else:
            files = ensoapi.get_selection().get("files", [])
            if files:
                if len(files) == 1:
                    filename = files[0]
                    img = None
                    try:
                        img = Image.open(filename)
                    except IOError, e:
                        ensoapi.display_message("An error occurred: %s." % e)
                    if img:
                        return func(ensoapi, img)
                else:
                    ensoapi.display_message("More than one file selected.")
            else:
                ensoapi.display_message("No image in clipboard, and no "
                                        "file selected.")
    return wrapper

@image_command
def cmd_get_image_size(ensoapi, img):
    outputfile = StringIO()
    img.save(outputfile, "PNG")
    png_size = outputfile.tell()
    outputfile = StringIO()
    img.save(outputfile, "JPEG", quality=90)
    jpg_size = outputfile.tell()
    ensoapi.display_message("png size: %d bytes. jpg-90 size: %d bytes." %
                            (png_size, jpg_size))

def cmd_unupload_image(ensoapi):
    url = ensoapi.get_selection().get("text", "")
    if url:
        if url.startswith(REMOTE_UPLOAD_URL):
            filename = url[len(REMOTE_UPLOAD_URL):]
            localfile = os.path.join(LOCAL_UPLOAD_DIR, filename)
            # It's just easier to upload a truncated file than it is
            # to remove the file remotely.
            open(localfile, "w").close()
            popen = subprocess.Popen(
                ["scp",
                 localfile,
                 "%s%s" % (REMOTE_UPLOAD_DIR, filename)]
                )
            while popen.poll() is None:
                yield
            if popen.returncode == 0:
                os.remove(localfile)
                ensoapi.display_message("Image removed.")
            else:
                ensoapi.display_message("An error occurred.")
        else:
            ensoapi.display_message("URL is not an upload URL.")
    else:
        ensoapi.display_message("No selection!")

LOCAL_UPLOAD_DIR = "/Users/varmaa/Archive/toolness-images/"
REMOTE_UPLOAD_DIR = "toolness.com:/home/varmaa/toolness.com/images/"
REMOTE_UPLOAD_URL = "http://www.toolness.com/images/"

@image_command
def cmd_upload_image(ensoapi, img):
    filename = "%s.jpg" % _get_filelike_timestamp()
    localfile = os.path.join(LOCAL_UPLOAD_DIR, filename)
    img.save(localfile, quality=90)

    ensoapi.display_message("Uploading image...")

    popen = subprocess.Popen(
        ["scp",
         localfile,
         "%s%s" % (REMOTE_UPLOAD_DIR, filename)]
        )
    while popen.poll() is None:
        yield
    if popen.returncode == 0:
        webbrowser.open("%s%s" % (REMOTE_UPLOAD_URL, filename))
    else:
        ensoapi.display_message("An error occurred.")

class ThreadedFunc(threading.Thread):
    def __init__(self, target):
        self.__target = target
        threading.Thread.__init__(self)
        self.__success = False
        self.__retval = None
        self.start()

    def run(self):
        self.__retval = self.__target()
        self.__success = True

    def wasSuccessful(self):
        if self.isAlive():
            raise Exception( "Thread not finished" )
        return self.__success

    def getRetval(self):
        if self.isAlive():
            raise Exception( "Thread not finished" )
        return self.__retval

def htmlifier(func):
    def wrapper(ensoapi):
        seldict = ensoapi.get_selection()
        text = seldict.get("text", "")
        html = seldict.get("html", text)
        if not text:
            ensoapi.display_message("No selection!")
        else:
            result = func(ensoapi, html)
            ensoapi.set_selection(
                {"html":result,
                 "text":result}
                )

    return wrapper

@htmlifier
def cmd_bold(ensoapi, text):
    return "<b>%s</b>" % text

@htmlifier
def cmd_italics(ensoapi, text):
    return "<i>%s</i>" % text

@htmlifier
def cmd_monospace(ensoapi, text):
    return "<pre>%s</pre>" % text

def cmd_normalize(ensoapi):
    normal_template = "<span style=\"font-weight: normal;\">%s</span>"
    seldict = ensoapi.get_selection()
    text = seldict.get("text", "")
    if not text:
        ensoapi.display_message("No selection!")
    else:
        ensoapi.set_selection(
            {"html":normal_template % text,
             "text":text} )

def cmd_paste_html(ensoapi):
    ensoapi.set_selection(
        {"text":"u do not support html.",
         "html":"<p>hai2u, <i>u support html</i>!</p>"}
        )

def cmd_get_pb_info(ensoapi):
    import AppKit

    pb = AppKit.NSPasteboard.generalPasteboard()

    pbtypes = pb.types()
    for string in pbtypes:
        print "type: %s" % string

def make_get_url_func(url):
    def get_url():
        import urllib2

        f = urllib2.urlopen(url)
        return f.read()
    return get_url

def get_weather(xml_data):
    """
    Shows the weather for the given place.
    """

    import elementtree.ElementTree as ET

    page = ET.fromstring(xml_data)

    weather = page.find( "weather/current_conditions" )

    return {
        'f' : weather.find( "temp_f" ).get( "data" ),
        'c' : weather.find( "temp_c" ).get( "data" ),
        'humidity' : weather.find( "humidity" ).get( "data" ),
        'wind' : weather.find( "wind_condition" ).get( "data" )
        }

def test_get_weather():
    xml_data = """<?xml version="1.0"?><xml_api_reply version="1"><weather module_id="0" tab_id="0"><forecast_information><city data="Chicago, IL"/><postal_code data="60657"/><latitude_e6 data=""/><longitude_e6 data=""/><forecast_date data="2008-04-07"/><current_date_time data="2008-04-07 06:38:00 +0000"/><unit_system data="US"/></forecast_information><current_conditions><condition data="Cloudy"/><temp_f data="57"/><temp_c data="14"/><humidity data="Humidity: 47%"/><icon data="/images/weather/cloudy.gif"/><wind_condition data="Wind: N at 0 mph"/></current_conditions><forecast_conditions><day_of_week data="Today"/><low data="40"/><high data="56"/><icon data="/images/weather/cloudy.gif"/><condition data="Cloudy"/></forecast_conditions><forecast_conditions><day_of_week data="Tue"/><low data="45"/><high data="54"/><icon data="/images/weather/thunderstorm.gif"/><condition data="Thunderstorm"/></forecast_conditions><forecast_conditions><day_of_week data="Wed"/><low data="40"/><high data="54"/><icon data="/images/weather/mostly_sunny.gif"/><condition data="Partly Sunny"/></forecast_conditions><forecast_conditions><day_of_week data="Thu"/><low data="38"/><high data="49"/><icon data="/images/weather/chance_of_rain.gif"/><condition data="Chance of Showers"/></forecast_conditions></weather></xml_api_reply>"""

    assert get_weather(xml_data) == {'c': '14', 'humidity': 'Humidity: 47%', 'wind': 'Wind: N at 0 mph', 'f': '57'}

def cmd_weather(ensoapi, place="san francisco"):
    zipcode = cmd_weather.places[place]
    url = "http://www.google.com/ig/api?weather=%s" % zipcode
    thread = ThreadedFunc(make_get_url_func(url))
    while thread.isAlive():
        yield
    weather_xml = thread.getRetval()
    if not weather_xml:
        ensoapi.display_message("An error occurred when getting the weather.")
    else:
        wdict = get_weather(weather_xml)
        wdict["place"] = place
        ensoapi.display_message(u"In %(place)s it is "
                                u"%(f)s\u00b0F/%(c)s\u00b0C, "
                                u"%(humidity)s, %(wind)s." % wdict)

cmd_weather.places = { "san francisco" : "94115",
                       "chicago" : "60640",
                       "mountain view" : "94043" }

cmd_weather.valid_args = cmd_weather.places.keys()

def cmd_what_is_my_ip(ensoapi):
    thread = ThreadedFunc(make_get_url_func("http://www.toolness.com/ip/"))
    while thread.isAlive():
        yield
    ensoapi.display_message("%s." % thread.getRetval())

def cmd_character_count(ensoapi):
    text = ensoapi.get_selection().get("text", "").strip()
    if not text:
        ensoapi.display_message( "No selection." )
    ensoapi.display_message( "%d characters." % len(text) )

def cmd_email_to_me(ensoapi):
    text = ensoapi.get_selection().get("text", "").strip()
    if not text:
        ensoapi.display_message( "No selection." )
    else:
        server = "mail.toolness.com"
        port = 587
        username = "no-reply@toolness.com"
        password = "4p5o3j45ot%$"

        mailfrom = "varmaa@gmail.com"
        rcpttos = ["varmaa@gmail.com"]

        text = text.encode("ascii", "xmlcharrefreplace")
        subject = text.splitlines()[0]
        text = ("This message was sent by Enso's "
                "'email to' command.\n\n" + text)
        data = "From: %s\r\nTo: %s\r\nSubject: %s\r\n\r\n%s" % \
            (mailfrom, ", ".join(rcpttos), subject, text)

        def sendmail():
            import smtplib

            try:
                svr = smtplib.SMTP( server, port )
                svr.login( username, password )
                svr.sendmail( mailfrom, rcpttos, data )
                svr.quit()
            except:
                success[0] = False
                raise

        thread = ThreadedFunc(sendmail)
        ensoapi.display_message( "Sending message..." )
        while thread.isAlive():
            yield
        if thread.wasSuccessful():
            ensoapi.display_message( "Message sent." )
        else:
            ensoapi.display_message(
                "An error occurred when sending the message."
                )

def cmd_date(ensoapi):
    import time

    ensoapi.display_message( "%s" % time.asctime() )

def cmd_insert_date(ensoapi):
    import time

    ensoapi.set_selection( time.asctime() )

class WebSearchCmd(object):
    def __init__(self, url_template):
        self._url_template = url_template

    def __call__(self, ensoapi, query=None):
        if not query:
            query = ensoapi.get_selection().get("text", u"")
        query = query.strip()

        if not query:
            ensoapi.display_message( "No query." )
            return

        query = urllib.quote( query.encode("utf-8") )        

        webbrowser.open( self._url_template % {"query" : query} )

cmd_wiki = WebSearchCmd("http://en.wikipedia.org/wiki/%(query)s")
cmd_wowhead = WebSearchCmd("http://www.wowhead.com/?search=%(query)s")
cmd_amaz = WebSearchCmd("http://www.amazon.com/exec/obidos/search-handle-url/index%%3Dblended%%26field-keywords%%3D%(query)s%%26store-name%%3Dall-product-search")
cmd_yp = WebSearchCmd("http://local.google.com/local?sc=1&q=%(query)s&near=2418+washington+94115&btnG=Google+Search")
cmd_imdb = WebSearchCmd("http://www.imdb.com/find?s=all&q=%(query)s&x=0&y=0")
cmd_mdc = WebSearchCmd("http://www.google.com/search?hl=en&q=%(query)s+site%%3Adeveloper.mozilla.org&btnG=Google+Search")
cmd_mxr = WebSearchCmd("http://mxr.mozilla.org/mozilla/search?string=%(query)s")
cmd_phonebook = WebSearchCmd("https://ldap.mozilla.org/phonebook/search.php?search=%(query)s")

# For help on this one see http://www.squarefree.com/bugzilla/quicksearch-help.html
cmd_bugzilla = WebSearchCmd("https://bugzilla.mozilla.org/buglist.cgi?quicksearch=%(query)s")

def cmd_farewell(ensoapi):
    import AppKit

    app = AppKit.NSApplication.sharedApplication()
    app.terminate_(None)

class Launcher(object):
    def __init__(self):
        import Foundation
        import AppKit

        self._targets = {}

        query = Foundation.NSMetadataQuery.alloc().init()
        queryString = ( "((kMDItemKind == \"Application\") "
                        " and (kMDItemSupportFileType != \"MDSystemFile\"))" )
        queryString += " or (kMDItemKind == \"Mac OS X Preference Pane\")"
        predicate = Foundation.NSPredicate.predicateWithFormat_(
            queryString
            )
        query.setPredicate_( predicate )
        if query.startQuery() != True:
            raise Exception( "startQuery() failed." )
        self._query = query
        self._workspace = AppKit.NSWorkspace.sharedWorkspace()
        self._targets = {}

    def get_namespace(self):
        return self._targets.keys()

    def get_target(self, name):
        return self._targets[name]

    def update(self):
        query = self._query

        while query.isGathering():
            yield

        # TODO: Modify this so we just get notified whenever the query
        # results change instead of constantly "polling" every time
        # the quasimode starts.

        resultList = []
        targets = {}

        query.disableUpdates()
        numresults = query.resultCount()

        BATCH_SIZE = 10

        for i in range( numresults ):
            result = query.resultAtIndex_( i )
            fsname = result.valueForAttribute_("kMDItemFSName")
            name = result.valueForAttribute_("kMDItemDisplayName")
            kind = result.valueForAttribute_("kMDItemKind")
            if name:
                name = name.lower()
                itempath = result.valueForAttribute_("kMDItemPath")
                if kind == "Mac OS X Preference Pane":
                    name += " preferences"
                    target = ShellOpenLaunchableTarget(itempath)
                else:
                    target = AppLaunchableTarget(self._workspace, itempath)
                resultList.append(name)
                targets[name] = target
            if i / BATCH_SIZE == i / float(BATCH_SIZE):
                yield
        #print "total results: %s" % numresults
        query.enableUpdates()
        targets["computer"] = ShellOpenLaunchableTarget("/")
        self._targets = targets

class AppLaunchableTarget(object):
    def __init__(self, workspace, path):
        self._workspace = workspace
        self._path = path

    def launch(self, with_files=None):
        if with_files:
            for filename in with_files:
                self._workspace.openFile_withApplication_(
                    filename,
                    self._path
                    )
        else:
            self._workspace.launchApplication_( self._path )

    def can_launch_with(self):
        return True

class ShellOpenLaunchableTarget(object):
    def __init__(self, path):
        self._path = path

    def launch(self):
        subprocess.Popen( ["open", self._path] )

    def can_launch_with(self):
        return False

class OpenCommand(object):
    """
    Opens an application, folder, or URL.
    """

    def __init__(self, launcher):
        self.launcher = launcher
        self._isFetchingArgs = False

    def on_quasimode_start(self):
        if self._isFetchingArgs:
            return

        self._isFetchingArgs = True

        for _ in self.launcher.update():
            yield

        self.valid_args = self.launcher.get_namespace()

        self._isFetchingArgs = False

    valid_args = []

    def __call__(self, ensoapi, target=None):
        if not target:
            seldict = ensoapi.get_selection()
            if seldict.get("files"):
                for file in seldict["files"]:
                    subprocess.Popen( ["open", file] )
            elif seldict.get("text"):
                filename = seldict["text"].strip()
                if os.path.isabs(filename):
                    subprocess.Popen( ["open", filename] )
                else:
                    webbrowser.open(filename)
        else:
            self.launcher.get_target(target).launch()

class OpenWithCommand(object):
    """
    Opens the selected file(s) with a particular application.
    """

    def __init__(self, launcher):
        self.launcher = launcher

    def _get_valid_args(self):
        return self.launcher.get_namespace()

    valid_args = property(_get_valid_args)

    def __call__(self, ensoapi, target):
        files = ensoapi.get_selection().get("files", [])
        targ = self.launcher.get_target(target)
        if not files:
            ensoapi.display_message("No files selected!")
        elif not targ.can_launch_with():
            ensoapi.display_message("Can't open files with %s." % target)
        else:
            targ.launch(files)

cmd_go = OpenCommand(Launcher())
cmd_open = cmd_go
cmd_bust_with = OpenWithCommand(cmd_open.launcher)

def cmd_run_python(ensoapi):
    """
    runs the selected text as python code.
    """

    text = ensoapi.get_selection().get("text","")

    if not text:
        ensoapi.display_message("No text selection!")
        return

    output_fd, output_name = tempfile.mkstemp()

    # TODO: This is for OSX only; will have to figure out what to do
    # for other platforms.
    cmd = text.replace( "\r", "\n" )

    try:
        compile( cmd, "<selected text>", "eval" )
        is_eval = True
    except:
        is_eval = False

    if is_eval:
        cmd = "print %s," % cmd

    cmd = ("try:\n"
           "  from autoimp import *\n"
           "except ImportError:\n"
           "  pass\n\n" + cmd )

    popen = subprocess.Popen(
        [ sys.executable,
          "-c", cmd ],
        stdout = output_fd,
        stderr = subprocess.STDOUT,
        )

    while popen.poll() is None:
        yield

    os.close(output_fd)

    output_text = open(output_name, "r").read().strip()
    if output_text:
        seldict = {"text" : "\n".join([text, output_text])}
        ensoapi.set_selection(seldict)
    else:
        if popen.returncode == 0:
            ensoapi.display_message("Code run successfully.")
        else:
            ensoapi.display_message("An error occurred.")

    os.remove(output_name)

def cmd_doctest(ensoapi):
    """
    python doctests the selected section of plain text.
    """

    text = ensoapi.get_selection().get("text","")

    if not text:
        ensoapi.display_message("No text selection!")
        return

    # TODO: This is for OSX only; will have to figure out what to do
    # for other platforms.
    new_text = text.replace( "\r", "\n" )

    fd, source_name = tempfile.mkstemp()
    os.close(fd)
    open(source_name, "wb").write(new_text)

    output_fd, output_name = tempfile.mkstemp()

    cmd = ("import doctest; doctest.testfile(%s, "
           "module_relative=False)" % repr(source_name))

    popen = subprocess.Popen(
        [ sys.executable,
          "-c", cmd ],
        stdout = output_fd,
        stderr = subprocess.STDOUT,
        )

    while popen.poll() is None:
        yield

    os.close(output_fd)

    if popen.returncode == 0:
        output_text = open(output_name, "r").read()
        if output_text:
            seldict = {"text":text + output_text}
            ensoapi.set_selection(seldict)
        else:
            ensoapi.display_message("All doctests successful!")
    else:
        ensoapi.display_message("An error occurred.")

    os.remove(source_name)
    os.remove(output_name)

def cmd_nosetest(ensoapi):
    """
    runs nosetests on the selected region of python code.
    """

    text = ensoapi.get_selection().get("text","")

    if not text:
        ensoapi.display_message("No text selection!")
        return

    # TODO: This is for OSX only; will have to figure out what to do
    # for other platforms.
    new_text = text.replace( "\r", "\n" )

    fd, source_name = tempfile.mkstemp(suffix=".py")
    os.close(fd)
    open(source_name, "wb").write(new_text)

    output_fd, output_name = tempfile.mkstemp()

    popen = subprocess.Popen(
        [ "nosetests",
          source_name,
          "--with-doctest" ],
        stdout = output_fd,
        stderr = subprocess.STDOUT,
        )

    while popen.poll() is None:
        yield

    os.close(output_fd)

    output_text = open(output_name, "r").read()
    if output_text:
        if popen.returncode == 0:
            lines = output_text.splitlines()
            ensoapi.display_message(lines[2])
        else:
            seldict = {"text":text + output_text}
            ensoapi.set_selection(seldict)
    else:
        raise AssertionError( "nosetests didn't return anything!" )

    os.remove(source_name)
    os.remove(output_name)

def cmd_insert_html(ensoapi):
    ensoapi.set_selection( {"html":"<b>hi</b> <p>there</p>"} )

def _runAppleScript( script ):
    params = [ "osascript", "-e", script ]
    popen = subprocess.Popen( params )

def cmd_screen_saver(ensoapi):
    """
    Starts your screen saver.
    """

    _runAppleScript(
        "tell application id \"com.apple.ScreenSaver.Engine\" "
        "to launch"
        )

def cmd_sleep(ensoapi):
    """
    Puts your computer to sleep.
    """

    _runAppleScript(
        "tell application \"Finder\" to sleep"
        )

def cmd_play(ensoapi):
    """
    Plays the current iTunes song.
    """

    _runAppleScript(
        "tell application \"iTunes\" to play"
        )

def cmd_pause(ensoapi):
    """
    Pauses the current iTunes song.
    """

    _runAppleScript(
        "tell application \"iTunes\" to pause"
        )


def cmd_next_track(ensoapi):
    """
    Goes to the next track on iTunes.
    """

    _runAppleScript(
        "tell application \"iTunes\" to next track"
        )

def cmd_previous_track(ensoapi):
    """
    Goes to the previous track on iTunes.
    """

    _runAppleScript(
        "tell application \"iTunes\" to back track"
        )

KIRITSU_DIR = "/Users/varmaa/Documents/kiritsu"
KIRITSU_MAKE_SCRIPT = "%s/MakeEverything.py" % KIRITSU_DIR
KIRITSU_VIEW_TEMPLATE = "file://%s/%s.html"
KIRITSU_VIEWS = ["work", "play", "chores"]

def cmd_refresh_kiritsu(ensoapi):
    """
    Refreshes all kiritsu feeds.
    """

    popen = subprocess.Popen(
        [sys.executable,
         KIRITSU_MAKE_SCRIPT],
        cwd = KIRITSU_DIR
        )

    ensoapi.display_message( "Please wait while kiritsu retrieves "
                             "new feeds." )

    while popen.poll() is None:
        yield

    if popen.returncode != 0:
        ensoapi.display_message( "An error occurred in Kiritsu." )
    else:
        ensoapi.display_message( "Kiritsu is done." )

def cmd_view( ensoapi, viewname ):
    """
    Opens the given kiritsu view.
    """

    webbrowser.open( KIRITSU_VIEW_TEMPLATE % (KIRITSU_DIR, viewname) )

cmd_view.valid_args = KIRITSU_VIEWS

def cmd_rest(ensoapi):
    import sys

    ensoapi.display_message( "please wait..." )
    popen = subprocess.Popen(
        [ sys.executable,
          "-c", "import time;time.sleep(2.0)" ]
        )
    while popen.poll() is None:
        yield
    if popen.returncode == 0:
        msg = "done!"
    else:
        msg = "an error occurred."
    ensoapi.display_message( msg )

def cmd_html_template(ensoapi):
    ensoapi.set_selection({"text" : HTML_TEMPLATE})

HTML_TEMPLATE = """\
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
          "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
  <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
  <link rel="stylesheet" type="text/css" media="all"
        href="" />
  <title></title>
</head>
<body>

</body>
<script type="text/javascript" src=""></script>
</html>
"""