subclim_plugin.py

'''Integrates ST2 with Eclim running in an Eclipse instance.
Enables Java completions / go to definition etc'''
import sublime_plugin
import sublime
import eclim
import re
import os
import json
import Queue
import threading
import subclim_logging

log = subclim_logging.getLogger('subclim')
settings = sublime.load_settings("Subclim.sublime-settings")
auto_complete = settings.get("subclim_auto_complete", True)


def auto_complete_changed():
    global auto_complete
    auto_complete = settings.get("subclim_auto_complete", True)
settings.add_on_change("subclim_auto_complete", auto_complete_changed)


# worker thread for async tasks
def worker():
    while True:
        task = tasks.get()
        try:
            task()
        except:
            import traceback
            traceback.print_exc()
        finally:
            tasks.task_done()
tasks = Queue.Queue()
t = threading.Thread(target=worker)
t.daemon = True
t.start()


def flatten_command_line(lst):
    '''shallow flatten for sequences of strings'''
    return [i for sub in lst for i in ([sub] if isinstance(sub, basestring) else sub)]


class UnknownSubclimTemplateHandlerException(Exception):
    pass


class SubclimBase(object):
    def __init__(self, *args, **kwargs):
        self.template_handler = SubclimBase.DEFAULT_HANDLER.copy()

    def is_configured(self):
        return check_eclim()

    def find_view(self, view):
        if type(view) == sublime.View:
            return view
        view = getattr(self, 'view', None)
        if type(view) == sublime.View:
            return view
        window = getattr(self, 'window', None)
        if type(window) == sublime.Window:
            return window.active_view()
        return sublime.active_window().active_view()

    def get_relative_path(self, flag, view):
        return (flag, get_context(view)[1])

    def get_project(self, flag, view):
        return (flag, get_context(view)[0])

    def get_cursor(self, flag, view):
        return (flag, str(view.sel()[0].a))

    def get_selection_start(self, flag, view):
        s = view.sel()
        if len(s) == 1 and s[0].a == s[0].b:
            return (flag, '0')
        e = min([min(i.a, i.b) for i in s])
        return (flag, str(e))

    def get_selection_end(self, flag, view):
        s = view.sel()
        if len(s) == 1 and s[0].a == s[0].b:
            return (flag, str(view.layout_to_text(view.layout_extent())))
        e = max([max(i.a, i.b) for i in s])
        return (flag, str(e))

    def get_encoding(self, flag, view):
        enc = view.encoding()
        if enc == "Undefined":
            enc = "utf-8"
        return (flag, enc)

    def get_classname(self, flag, view):
        return (flag, os.path.splitext(view.file_name())[0])

    def build_template(self, template, view=None, **kwargs):
        view = self.find_view(view)
        k = template.keys()[0]
        handler = getattr(self, 'template_handler', SubclimBase.DEFAULT_HANDLER)
        cmdline = ['-command', k]
        for param in template[k]:
            scrub = param.replace('[', '').replace(']', '')
            if ' ' in scrub:
                flag, _ = scrub.split(' ', 1)
            else:
                flag = scrub
            # ignore optional parameters
            if param not in handler:
                if param.startswith('['):
                    log.warn('ignoring missing optional parameter: %s', param)
                    continue
                if flag in kwargs:
                    continue
                log.error('error finding paramter: %s', param)
                raise UnknownSubclimTemplateHandlerException(param)
            cmdline.append(handler[param](self, flag, view))
        return cmdline

    def get_additional_args(self, d):
        '''if we've been passed command line options, add them in'''
        return [((k, v) if v is not None else k) for k, v in d.items() if k.startswith('-')]

    def run_template(self, template, view=None, **kwargs):
        cmdline = self.build_template(template, view, **kwargs)
        cmdline.extend(self.get_additional_args(kwargs))
        return self.run_eclim(cmdline)

    def run_eclim(self, cmdline):
        log.info(cmdline)
        flat = flatten_command_line(cmdline)
        return eclim.call_eclim(flat)

    # each handler called with self, flag, view
    DEFAULT_HANDLER = {
        '-f file': get_relative_path,
        '-p project': get_project,
        '-o offset': get_cursor,
        '-b boffset': get_selection_start,
        '-e eoffset': get_selection_end,
        '-e encoding': get_encoding
        # '-c class' : get_classname
    }


class EclimCommand(sublime_plugin.TextCommand, SubclimBase):
    '''To be run from the python console or other nefariousness'''
    def run(self, edit, **kwargs):
        cmdline = self.get_additional_args(kwargs)
        self.run_eclim(cmdline)


def check_eclim_version():
    out = SubclimBase.run_template({"ping": []}, {})
    m = re.search(r'^eclim\s+(.*)$', out, re.MULTILINE)
    version = int("".join(m.group(1).split(".")))
    if version < 173:
        sublime.error_message("Subclim depends on Eclim 1.7.3 or higher. Please update your Eclim installation.")


def initialize_eclim_module():
    '''Loads the eclim executable path from ST2's settings and sets it
    in the eclim module'''
    s = sublime.load_settings("Subclim.sublime-settings")
    eclim_executable = s.get("eclim_executable_location", None)
    # log.debug('eclim_executable = ' + eclim_executable)
    eclim.eclim_executable = eclim_executable

# when this module is loaded (by ST2), initialize the eclim module
initialize_eclim_module()


def check_eclim(view=None):
    if not eclim.eclim_executable:
        initialize_eclim_module()
    if not eclim.eclim_executable:
        log.error("Eclim executable path not set, call the set_eclim_path command!")
        return False
    return True


def get_context(view):
    s = view.settings()
    project = s.get('subclim.project', None)
    relative_path = s.get('subclim.project_relative_path', None)
    if project is None:
        project, relative_path = eclim.get_context(view.file_name())
        if project is not None:
            s.set('subclim.project', project)
        if relative_path is not None:
            s.set('subclim.project_relative_path', relative_path)
    return project, relative_path


def get_classname(view):
    s = view.settings()
    klass = s.get('subclim.classname', None)
    if klass is None:
        # todo
        return None
    return klass


class SetEclimPath(sublime_plugin.WindowCommand):
    '''Asks the user for the path to the Eclim executable and saves it in
    ST2's prefernces'''
    def run(self):
        default_path = "/path/to/your/eclipse/eclim"
        initialize_eclim_module()
        if eclim.eclim_executable is not None:
            default_path = eclim.eclim_executable

        self.window.show_input_panel(
            "Input path to eclim executable (in your eclipse directory)",
            default_path, self.path_entered, None, None)

    def path_entered(self, path):
        path = os.path.abspath(os.path.expanduser(path))
        s = sublime.load_settings("Subclim.sublime-settings")
        s.set("eclim_executable_location", path)
        sublime.save_settings("Subclim.sublime-settings")
        # re-initialize the eclim module with the new path
        initialize_eclim_module()


class SubclimGoBack(sublime_plugin.TextCommand):

    navigation_stack = []

    def run(self, edit, block=False):
        if len(SubclimGoBack.navigation_stack) > 0:
            self.view.window().open_file(
                SubclimGoBack.navigation_stack.pop(),
                sublime.ENCODED_POSITION)


class JavaGotoDefinition(sublime_plugin.TextCommand):
    '''Asks Eclipse for the definition location and moves ST2 there if found'''

    def run(self, edit, block=False):
        if not check_eclim(self.view):
            return
        project, file = get_context(self.view)
        pos = self.view.sel()[0]
        word = self.view.word(pos)
        locations = self.call_eclim(project, file, word.a, word.size())
        locations = self.to_list(locations)

        #  one definition was found and it is in a java file -> go there
        if len(locations) == 1:
            if locations[0]['filename'].endswith("java"):
                self.go_to_location(locations[0])
                return

        # we didnt return correctly, display error in statusbar
        error_msg = "Could not find definition of %s" % self.view.substr(word)
        log.error(error_msg)

    def call_eclim(self, project, filename, offset, ident_len, shell=True):
        eclim.update_java_src(project, filename)

        go_to_cmd = ['-command', 'java_search',
                        '-n', project,
                        '-f', filename,
                        '-o', str(offset),
                        '-e', 'utf-8',
                        '-l', str(ident_len)]
        out = eclim.call_eclim(go_to_cmd)
        return out

    def to_list(self, locations):
        return json.loads(locations)

    def go_to_location(self, loc):
        # save current position
        row, col = self.view.rowcol(self.view.sel()[0].a)
        SubclimGoBack.navigation_stack.append("%s:%d:%d" % (
            self.view.file_name(), row + 1, col + 1))

        # go to new position
        f, l, c = loc['filename'], loc['line'], loc['column']
        path = "%s:%s:%s" % (f, l, c)
        sublime.active_window().open_file(path, sublime.ENCODED_POSITION)


class JavaGotoUsages(JavaGotoDefinition):
    '''Asks Eclipse for the usage locations and moves ST2 there if found'''
    def run(self, edit, block=False):
        if not check_eclim(self.view):
            return
        project, file = get_context(self.view)
        pos = self.view.sel()[0]
        word = self.view.word(pos)
        locations = self.call_eclim(project, file, word.a, word.size())
        locations = self.to_list(locations)

        if len(locations) == 1:
            #  one definition was found and it is in a java file -> go there
            if locations[0]['filename'].endswith("java"):
                self.go_to_location(locations[0])
                return
        else:
            #  multiple usages -> show menu
            self.locations = locations
            self.view.window().show_quick_panel(
                [l['message'] for l in self.locations],
                self.location_selected, sublime.MONOSPACE_FONT)

    def location_selected(self, selected_idx):
        self.go_to_location(self.locations[selected_idx])

    def call_eclim(self, project, filename, offset, ident_len, shell=True):
        eclim.update_java_src(project, filename)

        go_to_cmd = ['-command', 'java_search',
                        '-n', project,
                        '-f', filename,
                        '-o', str(offset),
                        '-e', 'utf-8',
                        '-l', str(ident_len),
                        '-x', 'references']
        out = eclim.call_eclim(go_to_cmd)
        return out


class JavaRunClass(sublime_plugin.TextCommand):
    '''Runs the current class as Java program, good for testing
    small Java-"Scripts"'''

    def run(self, edit, block=False):
        if not check_eclim(self.view):
            return
        project, file_name = get_context(self.view)
        class_name, _ = os.path.splitext(os.path.basename(file_name))
        package_name = self.find_package_name()
        if package_name:
            class_name = package_name + "." + class_name
        result = self.call_eclim(project, file_name, class_name)
        # print stdout of Java program to ST2's console
        print result

    def find_package_name(self):
        '''Searches the current file line by line for the
        package definition.'''
        line_regions = self.view.split_by_newlines(
            sublime.Region(0, self.view.size()))
        for line_region in line_regions:
            line = self.view.substr(line_region)
            m = re.search(r'package ([^;]*);', line)
            if m:
                return m.group(1)
        return None

    def call_eclim(self, project, file_name, class_name):
        eclim.update_java_src(project, file_name)
        go_to_cmd = ['-command', 'java', '-p', project, '-c', class_name]
        out = eclim.call_eclim(go_to_cmd)
        return out


class CompletionProposal(object):
    def __init__(self, name, insert=None, type="None"):
        split = name.split(" ")
        self.name = "%s\t%s" % (split[0], " ".join(split[1:]))
        self.display = self.name
        if insert:
            self.insert = insert
        else:
            self.insert = name
        self.type = "None"

    def __repr__(self):
        return "CompletionProposal: %s %s" % (self.name, self.insert)


class ManualCompletionRequest(sublime_plugin.TextCommand):
    '''Used to request a full Eclim autocompletion when
    auto_complete is turned off'''
    def run(self, edit, block=False):
        JavaCompletions.user_requested = True
        self.view.run_command("save")
        self.view.run_command('auto_complete', {
                            'disable_auto_insert': True,
                            'api_completions_only': True,
                            'next_completion_if_showing': False,
                        })


class JavaCompletions(sublime_plugin.EventListener):
    '''Java/Scala completion provider'''
    # set when the just requested a manual completion, else False
    user_requested = False

    def on_query_completions(self, view, prefix, locations):
        if not (auto_complete or JavaCompletions.user_requested):
            return []
        JavaCompletions.user_requested = False

        c_func = self.complete_func(view)
        if not c_func:
            return []
        if not check_eclim(view):
            return []
        # if we haven't saved yet, push the auto complete to the main thread
        if view.is_dirty():
            sublime.set_timeout(lambda: self.queue_completions(view), 0)
            return []
        project, fn = get_context(view)
        pos = locations[0]
        proposals = self.to_proposals(c_func(project, fn, pos))
        return [(p.display, p.insert) for p in proposals]

    def queue_completions(self, view):
        view.run_command("save")
        view.run_command('auto_complete', {
                            'disable_auto_insert': True,
                            'api_completions_only': True,
                            'next_completion_if_showing': False,
                        })

    def complete_func(self, view):
        syntax = view.settings().get("syntax")
        if "Java.tmLanguage" in syntax:
            return self.call_eclim_java
        elif "Scala.tmLanguage" in syntax:
            return self.call_eclim_scala
        else:
            return None

    def call_eclim_java(self, project, file, offset, shell=True):
        eclim.update_java_src(project, file)
        complete_cmd = "-command java_complete \
                                -p %s \
                                -f %s \
                                -o %i \
                                -e utf-8 \
                                -l compact" % (project, file, offset)
        out = eclim.call_eclim(complete_cmd)
        return out

    def call_eclim_scala(self, project, file, offset, shell=True):
        eclim.update_scala_src(project, file)
        complete_cmd = "-command scala_complete \
                                -p %s \
                                -f %s \
                                -o %i \
                                -e utf-8 \
                                -l compact" % (project, file, offset)
        out = eclim.call_eclim(complete_cmd)
        return out

    def to_proposals(self, eclim_output):
        proposals = []
        completions = json.loads(eclim_output)["completions"]
        for c in completions:
            if not "<br/>" in c['info']:  # no overloads
                proposals.append(CompletionProposal(c['info'], c['completion']))
            else:
                variants = c['info'].split("<br/>")
                param_lists = [re.search(r'\((.*)\)', v) for v in variants]
                param_lists = [x.group(1) for x in param_lists if x]
                props = []
                for idx, pl in enumerate(param_lists):
                    if pl:
                        params = [par.split(" ")[-1] for par in pl.split(", ")]
                        insert = ", ".join(["${%i:%s}" % (i, s)
                                            for i, s in
                                            zip(range(1, len(params) + 1), params)
                                            ])
                        insert = c['completion'] + insert + ")"
                        props.append(CompletionProposal(variants[idx], insert))
                    else:
                        props.append(CompletionProposal(variants[idx], c['completion']))
                proposals.extend(props)
        return proposals


class JavaValidation(sublime_plugin.EventListener):
    '''Show Java errors as found by Eclipse on save and load.
    Will trigger Eclipse compiles.'''

    drawType = 4 | 32
    line_messages = {}

    def __init__(self, *args, **kwargs):
        sublime_plugin.EventListener.__init__(self, *args, **kwargs)
        self.lastCount = {}

    def validation_func(self, view):
        syntax = view.settings().get("syntax")
        if "Java.tmLanguage" in syntax:
            return eclim.update_java_src
        elif "Scala.tmLanguage" in syntax:
            return eclim.update_scala_src
        else:
            return None

    def on_load(self, view):
        validation_func = self.validation_func(view)
        if validation_func:
            buf_id = view.buffer_id()

            def validation_closure():
                try:
                    v = sublime.active_window().active_view()
                except AttributeError:
                    pass
                if v.buffer_id() == buf_id:
                    self.validate(view, validation_func)

            sublime.set_timeout(validation_closure, 1500)

    def on_post_save(self, view):
        validation_func = self.validation_func(view)
        if validation_func:
            self.validate(view, validation_func)

            # sometimes, Eclipse will not report errors instantly
            # check again a bit later
            def validation_closure():
                self.validate(view, validation_func)
            sublime.set_timeout(validation_closure, 1500)

    def validate(self, view, validation_func):
        if not check_eclim(view):
            return
        project, file = get_context(view)
        problems = {}

        def async_validate_task():
            out = validation_func(project, file)
            problems.update(eclim.parse_problems(out))
            sublime.set_timeout(on_validation_finished, 0)

        def on_validation_finished():
            line_messages = JavaValidation.line_messages
            vid = view.id()
            line_messages[vid] = {}
            for e in problems['errors']:
                l_no = int(e['line'])
                if not line_messages[vid].get(l_no, None):
                    line_messages[vid][l_no] = []
                line_messages[vid][l_no].append(e)
            self.visualize(view)

        tasks.put(async_validate_task)

    def visualize(self, view):
        view.erase_regions('subclim-errors')
        view.erase_regions('subclim-warnings')
        lines = JavaValidation.line_messages[view.id()]

        outlines = [view.line(view.text_point(lineno - 1, 0))
                    for lineno in lines.keys()
                    if len(filter(lambda x: x['error'], lines[lineno])) > 0]
        view.add_regions(
            'subclim-errors', outlines, 'keyword', 'dot', JavaValidation.drawType)

        outlines = [view.line(view.text_point(lineno - 1, 0))
                    for lineno in lines.keys()
                    if len(filter(lambda x: x['error'], lines[lineno])) <= 0]
        view.add_regions(
            'subclim-warnings', outlines, 'comment', 'dot', JavaValidation.drawType)

    def on_selection_modified(self, view):
        validation_func = self.validation_func(view)
        if validation_func:
            line_messages = JavaValidation.line_messages
            vid = view.id()
            lineno = view.rowcol(view.sel()[0].end())[0] + 1
            if vid in line_messages and lineno in line_messages[vid]:
                view.set_status(
                    'subclim', '; '.join([e['message'] for e in line_messages[vid][lineno]]))
            else:
                view.erase_status('subclim')


class JavaImportClassUnderCursor(sublime_plugin.TextCommand):
    '''Will try to find a suitable class for importing using
    Eclipse's auto import features. Displays a menu if there are
    alternatives.'''

    def run(self, edit, block=False):
        if not check_eclim(self.view):
            return
        project, _file = get_context(self.view)
        pos = self.view.sel()[0]
        word = self.view.substr(self.view.word(pos))
        self.view.run_command("save")

        class_names = []

        def async_find_imports_task():
            class_names.extend(self.call_eclim(project, _file, word))
            sublime.set_timeout(on_find_imports_finished, 0)

        def on_find_imports_finished():
            if not class_names:
                log.error("No suitable class found!")
                return
            if len(class_names) == 1:
                self.add_import(class_names[0], edit)
            else:
                self.edit = edit
                self.possible_imports = class_names
                self.show_import_menu()

        tasks.put(async_find_imports_task)

    def call_eclim(self, project, _file, identifier):
        eclim.update_java_src(project, _file)
        complete_cmd = "-command java_import \
                                -n %s \
                                -p %s" % (project, identifier)
        class_name = eclim.call_eclim(complete_cmd)
        class_name = json.loads(class_name)
        if class_name:
            return class_name
        else:
            return []

    def show_import_menu(self):
        self.view.window().show_quick_panel(
            self.possible_imports, self.import_selected,
            sublime.MONOSPACE_FONT)

    def import_selected(self, selected_idx):
        self.add_import(self.possible_imports[selected_idx], self.edit)

    def add_import(self, class_name, edit):
        import_string = "import " + class_name + ";\n"
        lines = self.view.lines(sublime.Region(0, self.view.size()))
        last_import_region = sublime.Region(-1, -1)
        package_definition = sublime.Region(-1, -1)
        for l in lines:
            l_str = self.view.substr(l)
            if "{" in l_str:
                break
            if "package" in l_str:
                package_definition = l
            if "import" in l_str:
                last_import_region = l

        if last_import_region == sublime.Region(-1, -1):
            last_import_region = package_definition
            import_string = "\n" + import_string
        self.view.insert(edit, last_import_region.b + 1, import_string)


class EclipseProjects(sublime_plugin.WindowCommand):
    '''Open an eclipse project'''
    def __init__(self, *args, **kwargs):
        sublime_plugin.WindowCommand.__init__(self, *args, **kwargs)
        self.projects = {}
        self.project_paths = []

    def run(self):
        if not check_eclim(self.window.active_view()):
            return
        self.projects = {}
        self.project_paths = []
        cmd = "-command projects"
        out = eclim.call_eclim(cmd)
        ps = json.loads(out.strip())
        for p in ps:
            self.projects[p['name']] = p
            self.project_paths.append([p['name'], p['path']])
        self.window.show_quick_panel(self.project_paths, self.on_done)

    def on_done(self, idx):
        name, path = self.project_paths[idx]
        branch, leaf = os.path.split(path)
        # open in finder
        self.window.run_command("open_dir", {"dir": branch, "file": leaf})
        # none of these work.
        # self.window.open_file(path)
        # self.window.run_command("prompt_add_folder", {"dir": path} )
        # self.window.run_command("prompt_add_folder", {"file": path} )
        # self.window.run_command("prompt_add_folder", path)