Now based on the new "sublimecompletioncommon" module

quarnster · quarnster · commit a651c772c379 · 2012-05-05T08:53:13.000+02:00
diff --git a/.gitmodules b/.gitmodules
@@ -1,3 +1,6 @@
 [submodule "parsehelp"]
 	path = parsehelp
 	url = git://github.com/quarnster/parsehelp.git
+[submodule "sublimecompletioncommon"]
+	path = sublimecompletioncommon
+	url = git://github.com/quarnster/SublimeCompletionCommon.git
diff --git a/Default.sublime-keymap b/Default.sublime-keymap
@@ -5,7 +5,7 @@
         [
             {"key": "sublimejava.supported_language"},
             {"key": "sublimejava.dotcomplete"},
-            {"key": "sublimejava.is_code"}
+            {"key": "completion_common.is_code"}
         ]
     }
 ]
diff --git a/README.creole b/README.creole
@@ -12,6 +12,8 @@ Please go [[https://github.com/quarnster/SublimeJava/issues?sort=created&directi
     * You need to manually install it using git
     ** Go to your packages directory and type:
     ***        git clone --recursive https://github.com/quarnster/SublimeJava SublimeJava
+    ** To update to the latest commit, use this command in the SublimeJava directory:
+    ***        git pull && git submodule update --init
     * You most likely want to configure the "sublimejava_classpath" setting to your own, issue [[https://github.com/quarnster/SublimeJava/issues/23|23]] details how this is done.
 
 === Usage ===
diff --git a/SublimeJava.java b/SublimeJava.java
@@ -283,7 +283,7 @@ else if (args[0].equals("-returntype"))
                 }
                 catch (Exception e)
                 {
-                    System.err.println("Exception caugth: " + e.getMessage());
+                    System.err.println("Exception caught: " + e.getMessage());
                     e.printStackTrace(System.err);
                 }
             }
diff --git a/parsehelp b/parsehelp
diff --git a/sublimecompletioncommon b/sublimecompletioncommon
@@ -0,0 +1 @@
+Subproject commit ea117a4045bfcfdb700ab30afab45be06594870a
diff --git a/sublimejava.py b/sublimejava.py
@@ -22,15 +22,9 @@
 """
 import sublime
 import sublime_plugin
-import re
-import subprocess
 import os.path
-import time
-import os
-import Queue
-import threading
 try:
-    from parsehelp import parsehelp
+    from sublimecompletioncommon import completioncommon
 except:
     def hack(func):
         # If there's a sublime.error_message before a window is open
@@ -55,277 +49,43 @@ def showError():
 for more details.""")
     hack(showError)
 
-scriptdir = os.path.dirname(os.path.abspath(__file__))
 
+class SublimeJavaDotComplete(completioncommon.CompletionCommonDotComplete):
+    pass
 
-def get_settings():
-    return sublime.load_settings("SublimeJava.sublime-settings")
-
-
-def get_setting(key, default=None):
-    try:
-        s = sublime.active_window().active_view().settings()
-        if s.has(key):
-            return s.get(key)
-    except:
-        pass
-    return get_settings().get(key, default)
-
-
-java_proc = None
-java_cmd = None
-data_queue = Queue.Queue()
-javaseparator = None  # just so that get_cmd references it. It's set "for real" later
-
-
-def get_cmd():
-    classpath = "."
-    if javaseparator != None:
-        classpath = get_setting("sublimejava_classpath", ["."])
-        classpath.append(".")
-        classpath = javaseparator.join(classpath)
-    return "java -classpath %s SublimeJava" % classpath
-
-
-def java_thread():
-    global java_cmd
-    try:
-        while True:
-            if java_proc.poll() != None:
-                break
-            read = java_proc.stdout.readline().strip()
-            #print "read: %s" % read
-            if read:
-                data_queue.put(read)
-    finally:
-        #print "java_proc: %d" % (java_proc.poll())
-        data_queue.put(";;--;;")
-        data_queue.put(";;--;;exit;;--;;")
-        java_cmd = None
-        print "no longer running"
-
-
-def run_java(cmd, stdin=None):
-    global java_proc
-    global java_cmd
-    realcmd = get_cmd()
-    if not java_proc or realcmd != java_cmd:
-        if java_proc:
-            java_proc.stdin.write("-quit\n")
-            while data_queue.get() != ";;--;;exit;;--;;":
-                continue
-
-        java_cmd = realcmd
-        java_proc = subprocess.Popen(
-            realcmd,
-            cwd=scriptdir,
-            shell=True,
-            stdout=subprocess.PIPE,
-            stdin=subprocess.PIPE
-            )
-        t = threading.Thread(target=java_thread)
-        t.start()
-    #print "wrote: %s" % cmd
-    java_proc.stdin.write(cmd+"\n")
-    if stdin:
-        #print "wrote: %s" % stdin
-        java_proc.stdin.write(stdin + "\n")
-    stdout = ""
-    while True:
-        try:
-            read = data_queue.get(timeout=5.0)
-            if read == ";;--;;" or read == None:
-                break
-            stdout += read+"\n"
-        except:
-            break
-    return stdout
-
-javaseparator = run_java("-separator").strip()
-
-language_regex = re.compile("(?<=source\.)[\w+#]+")
-member_regex = re.compile("(([a-zA-Z_]+[0-9_]*)|([\)\]])+)(\.)$")
-
-
-def get_language(view):
-    caret = view.sel()[0].a
-    scope = view.scope_name(caret).strip()
-    language = language_regex.search(scope)
-    if language == None:
-        if scope.endswith("jsp"):
-            return "jsp"
-        return None
-    return language.group(0)
-
-
-def is_supported_language(view):
-    if view.is_scratch() or not get_setting("sublimejava_enabled", True):
-        return False
-    language = get_language(view)
-    return language == "java" or language == "jsp"
-
-
-class SublimeJavaDotComplete(sublime_plugin.TextCommand):
-    def run(self, edit):
-        for region in self.view.sel():
-            self.view.insert(edit, region.end(), ".")
-        caret = self.view.sel()[0].begin()
-        line = self.view.substr(sublime.Region(self.view.word(caret-1).a, caret))
-        if member_regex.search(line) != None:
-            sublime.set_timeout(self.delayed_complete, 1)
-
-    def delayed_complete(self):
-        self.view.run_command("auto_complete")
-
-
-class SublimeJava(sublime_plugin.EventListener):
 
+class SublimeJavaCompletion(completioncommon.CompletionCommon):
     def __init__(self):
-        self.cache_list = []
-
-    def find_absolute_of_type(self, data, full_data, type):
-        thispackage = re.search("[ \t]*package (.*);", data)
-        if thispackage is None:
-            thispackage = ""
-        else:
-            thispackage = thispackage.group(1)
+        super(SublimeJavaCompletion, self).__init__("SublimeJava.sublime-settings", os.path.dirname(os.path.abspath(__file__)))
+        self.javaseparator = None  # just so that get_cmd references it. It's set "for real" later
+        self.javaseparator = self.run_completion("-separator").strip()
 
-        match = re.search("class %s" % type, full_data)
-        if not match is None:
-            # This type is defined in this file so figure out the nesting
-            full_data = parsehelp.remove_empty_classes(parsehelp.remove_preprocessing(parsehelp.collapse_brackets(full_data[:match.start()])))
-            regex = re.compile("\s*class\s+([^\\s{]+)")
-            add = ""
-            for m in re.finditer(regex, full_data):
-                if len(add):
-                    add = "%s$%s" % (add, m.group(1))
-                else:
-                    add = m.group(1)
+    def get_cmd(self):
+        classpath = "."
+        if self.javaseparator != None:
+            classpath = self.get_setting("sublimejava_classpath", ["."])
+            classpath.append(".")
+            classpath = self.javaseparator.join(classpath)
+        return "java -classpath %s SublimeJava" % classpath
 
-            if len(add):
-                type = "%s$%s" % (add, type)
-            # Class is defined in this file, return package of the file
-            if len(thispackage) == 0:
-                return type
-            return "%s.%s" % (thispackage, type)
+    def is_supported_language(self, view):
+        if view.is_scratch() or not self.get_setting("sublimejava_enabled", True):
+            return False
+        language = self.get_language(view)
+        return language == "java" or language == "jsp"
 
-        packages = re.findall("[ \t]*import[ \t]+(.*);", data)
-        packages.append("java.lang.*")
-        packages.append(thispackage + ".*")
-        packages.append("")  # for int, boolean, etc
-        for package in packages:
-            if package.endswith(".%s" % type):
-                # Explicit imports, we want these to have the highest
-                # priority when searching for the absolute type, so
-                # insert them at the top of the package list.
-                # Both the .* version and not is added so that
-                # blah.<searchedForClass> and blah$<searchedForClass>
-                # is tested
-                add = package[:-(len(type)+1)]
-                packages.insert(0, add + ".*")
-                packages.insert(1, add)
-                break
-        packages.append(";;--;;")
+comp = SublimeJavaCompletion()
 
-        output = run_java("-findclass %s" % (type), "\n".join(packages)).strip()
-        if len(output) == 0 and "." in type:
-            return self.find_absolute_of_type(data, full_data, type.replace(".", "$"))
-        return output
 
-    def complete_class(self, absolute_classname, prefix):
-        stdout = run_java("-complete %s %s" % (absolute_classname, prefix))
-        stdout = stdout.split("\n")[:-2]
-        members = [tuple(line.split(";;--;;")) for line in stdout]
-        ret = []
-        for member in members:
-            if member not in ret:
-                ret.append(member)
-        return sorted(ret, key=lambda a: a[0])
-
-    def get_return_type(self, absolute_classname, prefix):
-        stdout = run_java("-returntype %s %s" % (absolute_classname, prefix))
-        ret = stdout.strip()
-        match = re.search("(\[L)?([^;]+)", ret)
-        if match:
-            return match.group(2)
-        return ret
+class SublimeJava(sublime_plugin.EventListener):
 
     def on_query_completions(self, view, prefix, locations):
-        bs = time.time()
-        start = time.time()
-        if not is_supported_language(view):
-            return []
-        line = view.substr(sublime.Region(view.full_line(locations[0]).begin(), locations[0]))
-        before = line
-        if len(prefix) > 0:
-            before = line[:-len(prefix)]
-        if re.search("[ \t]+$", before):
-            before = ""
-        elif re.search("\.$", before):
-            # Member completion
-            data = view.substr(sublime.Region(0, locations[0]))
-            full_data = view.substr(sublime.Region(0, view.size()))
-            typedef = parsehelp.get_type_definition(data, before)
-            if typedef == None:
-                return []
-            line, column, typename, var, tocomplete = typedef
-
-            if typename is None:
-                # This is for completing for example "System."
-                # or "String." or other static calls/variables
-                typename = var
-            start = time.time()
-            typename = re.sub("(<.*>)|(\[.*\])", "", typename)
-            typename = self.find_absolute_of_type(data, full_data, typename)
-            end = time.time()
-            print "absolute is %s (%f ms)" % (typename, (end-start)*1000)
-            if typename == "":
-                return []
-
-            tocomplete = tocomplete[1:]  # skip initial .
-            start = time.time()
-            idx = tocomplete.find(".")
-            while idx != -1:
-                sub = tocomplete[:idx]
-                idx2 = sub.find("(")
-                if idx2 >= 0:
-                    sub = sub[:idx2]
-                    count = 1
-                    for i in range(idx+1, len(tocomplete)):
-                        if tocomplete[i] == '(':
-                            count += 1
-                        elif tocomplete[i] == ')':
-                            count -= 1
-                            if count == 0:
-                                idx = tocomplete.find(".", i)
-                                break
-
-                n = self.get_return_type(typename, sub)
-                print "%s.%s = %s" % (typename, sub, n)
-                typename = n
-                tocomplete = tocomplete[idx+1:]
-                idx = tocomplete.find(".")
-            end = time.time()
-            print "finding what to complete took %f ms" % ((end-start) * 1000)
-
-            print "completing %s.%s" % (typename, prefix)
-            start = time.time()
-            ret = self.complete_class(typename, prefix)
-            end = time.time()
-            print "completion took %f ms" % ((end-start)*1000)
-            be = time.time()
-            print "total %f ms" % ((be-bs)*1000)
-            return ret
-
-        print "here"
-        return []
+        return comp.on_query_completions(view, prefix, locations)
 
     def on_query_context(self, view, key, operator, operand, match_all):
         if key == "sublimejava.dotcomplete":
-            return get_setting(key.replace(".", "_"), True)
+            return comp.get_setting(key.replace(".", "_"), True)
         elif key == "sublimejava.supported_language":
-            return is_supported_language(view)
-        elif key == "sublimejava.is_code":
-            caret = view.sel()[0].a
-            scope = view.scope_name(caret).strip()
-            return re.search("(string.)|(comment.)", scope) == None
+            return comp.is_supported_language(view)
+        else:
+            return comp.on_query_context(view, key, operator, operand, match_all)

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`	`[`
`6`	`6`	`{"key": "sublimejava.supported_language"},`
`7`	`7`	`{"key": "sublimejava.dotcomplete"},`
`8`		`- {"key": "sublimejava.is_code"}`
	`8`	`+ {"key": "completion_common.is_code"}`
`9`	`9`	`]`
`10`	`10`	`}`
`11`	`11`	`]`
Original file line number	Diff line number	Diff line change
`@@ -283,7 +283,7 @@ else if (args[0].equals("-returntype"))`
`283`	`283`	`}`
`284`	`284`	`catch (Exception e)`
`285`	`285`	`{`
`286`		`- System.err.println("Exception caugth: " + e.getMessage());`
	`286`	`+ System.err.println("Exception caught: " + e.getMessage());`
`287`	`287`	`e.printStackTrace(System.err);`
`288`	`288`	`}`
`289`	`289`	`}`