test

ck_com_shell.py

import sublime
import sublime_plugin
import subprocess
import threading
import os
from subprocess import Popen, PIPE, STDOUT

"""
// --- these don't require the console prefix %> 
[-] chuck --shell : will start ChucK in --shell mode (server) using a new thread.
[-] kill : will end chuck (should end all chucks alive).

// --- these do, because it indicates that you expect an open console.
[-] %> -k : will kill ChucK server thread. (no space between -k)
[ ] %> + this: add shred (current open file), "this" will be reserved 
[ ] %> =/- this: replace/remove shred (current open file)
[ ] %> = x.ck: replace shred named x
[ ] %> - x.ck : remove shred named x
[ ] %> = number(s) : replace shred(s) by id, separated by spaces
[ ] %> - number(s) : remove shred(s) by id, separated by spaces
[ ] %> -all : remove all shreds. (no space between -all)
[ ] %> status: will print the status to the python console.

A key combo : will add selection as shred (sends everything enclosed in { } 
as an 'on the fly' shred)
"""

def kill_chuck():
    p = subprocess.call(["chuck", "--kill"])        
    print("ending a chuck process!")
    print(p)
    return

def com_parser(line_under_cursor, file_name):
    right_side = None

    try:
        found_content = line_under_cursor.rsplit("//", 1)[1]
        found_content = found_content.strip()

        if found_content in ("kill", "%> -k"):
            return "kill"

        if found_content == "chuck --shell":
            return "shell"

        sides = found_content.split("%>")
        right_side = sides[1].strip()

        # this will refer to the name of the current file.ck
        if "this" in right_side:
            right_side = right_side.replace("this", file_name)
       
    except: 
        print("unparsable")
        return

    return right_side


class Ck_com_shell(sublime_plugin.TextCommand):
    chuck_process = None
    chuck_queue = None
    chuck_thread = None

    def run(self, edit):
        view = self.view
        file_path = view.file_name()
        file_name = os.path.basename(file_path)

        selections = view.sel()
        if not selections[0].a == selections[0].b:
            print("see com shell documentation")
            return
        
        sel = view.line(selections[0])
        line_under_cursor = view.substr(sel)
        
        commands = com_parser(line_under_cursor, file_name)
        if not commands:
            return

        if commands == "kill":
            kill_chuck()
            return

        # start shell as subprocess in a thread.
        elif commands == "shell":
            self.chuck_thread = Ck_Shell(["chuck", "--shell"])
            self.chuck_thread.start()
            return

        if commands:
            print(commands)
            try:
                if self.chuck_thread.isAlive():
                    print("thread seems alive.")
            except:
                print("server seems lost, try: (re)starting it.")
                return

            finally:
                print("serving:", commands)
                commands += "\x0c"   # carriage return?
                shell = self.chuck_thread.shell_process
                stdout = shell.stdin.write(commands)
                print(stdout)




class Ck_Shell(threading.Thread):
    shell_process = None
    def __init__(self, commands):
        self.commands = commands
        threading.Thread.__init__(self)
 
    def run(self):
        print("starting shell")
        self.shell_process = Popen(self.commands, 
                        stdin = PIPE, 
                        stdout= PIPE, 
                        stderr= STDOUT, 
                        shell=True)
 
        print(self.shell_process.communicate())
 
# http://eli.thegreenplace.net/2011/12/27/python-threads-communication-and-stopping/
# http://stackoverflow.com/a/165662/1243487
# http://stackoverflow.com/questions/3065060/communicate-multiple-times-with-a-process-without-breaking-the-pipe