Send results to system.out instead of storing and then outputting. With that philosophy, don't cache everything in a map, either. Also, don't bother with non-under-cursor import.

delfoxie · delfoxie · commit e99245e45da6 · 2012-11-25T22:23:14.000-05:00
diff --git a/SublimeJava.java b/SublimeJava.java
@@ -282,7 +282,6 @@ private static boolean isPackage(String packageName)
         return false;
     }
 
-    private static Map<String, Set<String>> importMap = new HashMap<String, Set<String>>();
     private static final String CLASS_NAME_RE = "(?:$|.)?(\\w+).class";
     private static final String DIGITS_CLASS_NAME_RE = "\\d+";
     private static final String SUBLIME_JAVA_CLASS_RE = "SublimeJava";
@@ -295,27 +294,24 @@ private static boolean isPackage(String packageName)
         sublimeJavaClassPattern = Pattern.compile(SUBLIME_JAVA_CLASS_RE);
     }
 
-    private static void addToImportMap(String classFileName)
+    private static String getImport(String classFileName, String searchClass)
     {   
         Matcher classnameMatcher = classnamePattern.matcher(classFileName);
         if (classnameMatcher.find())
         {
             String classname = classnameMatcher.group(1);
-            Matcher digitsClassnameMatcher = digitsClassnamePattern.matcher(classname);
-            if (!digitsClassnameMatcher.find())
+            if ((searchClass != null && searchClass.equals(classname)) || 
+                (searchClass == null && !digitsClassnamePattern.matcher(classname).matches()))
             {
-                if (!importMap.containsKey(classname))
-                {
-                    importMap.put(classname, new HashSet<String>());
-                }
                 String fullClassname = classFileName.replace("/", ".").replace(".class", "");
                 if (fullClassname.startsWith("."))
                 {
                     fullClassname = fullClassname.substring(1);
                 }
-                importMap.get(classname).add(fullClassname);
+                return fullClassname;
             }
         }
+        return null;
     }
 
     private static String[] getClasspathEntries() 
@@ -356,90 +352,65 @@ private static URL getUrlFromClasspathEntry(ClassLoader classLoader, String clas
         return url;
     }
 
-    private static Set<File> getClassFilesNotInJar(File current) 
+    private static void printImportsNotInJar(File current, File root, String classname, Set<String> possibleImports) 
     {
-        Set<File> classFiles = new HashSet<File>();
-        if (current.isFile() && current.getName().endsWith(".class")) 
+        Matcher classnameMatcher = classnamePattern.matcher(current.getName());
+        if (current.isFile() && classnameMatcher.matches())
         {
-            classFiles.add(current);
+            if (classname == null || classname.equals(classnameMatcher.group(1)))
+            {
+                String classFileName = current.getAbsolutePath().substring(root.getAbsolutePath().length());
+                printPossibleImport(getImport(classFileName, classname), possibleImports);
+            }
         }
         else if (current.isDirectory()) 
         {
             for (File file : current.listFiles()) 
             {
-                classFiles.addAll(getClassFilesNotInJar(file));
+                printImportsNotInJar(file, root, classname, possibleImports);
             }
         }
-        return classFiles;
     }
 
     private static void getPossibleImports(String classname) 
         throws IOException
     {
-        boolean importMapPopulated = importMap.size() > 0;
-
-        if (!importMapPopulated)
+        Set<String> possibleImports = new HashSet<String>();
+        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
+        for (String s : getClasspathEntries())
         {
-            ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
-            for (String s : getClasspathEntries())
+            URL url = getUrlFromClasspathEntry(classLoader, s, "");
+            if (url == null)
+                continue;
+            System.err.println("s: " + s);
+            System.err.println("url: " + url);
+
+            String filename = URLDecoder.decode(url.getFile(), "UTF-8");
+            if (url.getProtocol().equals("jar"))
             {
-                URL url = getUrlFromClasspathEntry(classLoader, s, "");
-                if (url == null)
-                    continue;
-                System.err.println("s: " + s);
-                System.err.println("url: " + url);
+                filename = filename.substring(5, filename.indexOf("!"));
 
-                String filename = URLDecoder.decode(url.getFile(), "UTF-8");
-                if (url.getProtocol().equals("jar"))
+                JarFile jf = new JarFile(filename);
+                Enumeration<JarEntry> entries = jf.entries();
+                while (entries.hasMoreElements())
                 {
-                    filename = filename.substring(5, filename.indexOf("!"));
+                    String imp = getImport(entries.nextElement().getName(), classname);
+                    printPossibleImport(imp, possibleImports);
 
-                    JarFile jf = new JarFile(filename);
-                    Enumeration<JarEntry> entries = jf.entries();
-                    while (entries.hasMoreElements())
-                    {
-                        addToImportMap(entries.nextElement().getName());
-                    }
-                }
-                else
-                {
-                    File folder = new File(filename);
-                    File[] classFiles = getClassFilesNotInJar(folder).toArray(new File[0]);
-                    for (File classFile : classFiles) 
-                    {
-                        addToImportMap(classFile.getAbsolutePath().substring(folder.getAbsolutePath().length()));
-                    }
                 }
             }
-        }
-
-        if (classname != null)
-        {
-            Set<String> possibleImports = importMap.get(classname);
-            if (possibleImports != null) 
-            {
-                printImports(possibleImports);
-            }
-        }
-        else
-        {
-            for (Set<String> imports : importMap.values())
+            else
             {
-                printImports(imports);
+                File folder = new File(filename);
+                printImportsNotInJar(folder, folder, classname, possibleImports);
             }
         }
-        
     }
 
-    private static void printImports(Set<String> imports)
+    private static void printPossibleImport(String fullClassname, Set<String> possibleImports)
     {
-        for (String impClass : imports)
-        {
-            if (!sublimeJavaClassPattern.matcher(impClass).matches())
-            {
-                System.out.println(impClass);
-            }
-        }
+        if (fullClassname != null && possibleImports.add(fullClassname))
+            System.out.println(fullClassname);
     }
 
     private static void completePackage(String packageName) 
@@ -588,7 +559,7 @@ else if (args[0].equals("-findclass"))
                             for (String pack : packages)
                             {
                                 String classname = getClassname(pack, args[1]);
-                                while (!found && classname.indexOf('.') != -1)
+                                while (!found && classname != null && classname.indexOf('.') != -1)
                                 {
                                     int idx = classname.lastIndexOf('.');
                                     classname = classname.substring(0, idx) + "$" + classname.substring(idx+1);
diff --git a/SublimeJava.sublime-commands b/SublimeJava.sublime-commands
@@ -1,8 +1,4 @@
 [
-    {
-        "caption": "Java: Import Class",
-        "command": "import_java_class"
-    },
     {
         "caption": "Java: Import Class Under Cursor",
         "command": "import_java_class",
diff --git a/classopener.py b/classopener.py
@@ -1,5 +1,6 @@
 import os
 import webbrowser
+import sublime
 
 path_to_full = lambda path: '.'.join(path.split('/'))
 remove_dollar = lambda classname: classname.replace('$$', '.')
@@ -29,8 +30,10 @@ def do_open(result):
 
         if classname is not None and len(options) == 1:
             do_open(0)
-        else:
+        elif len(options) > 1:
             self.window.show_quick_panel([t[0] for t in options], do_open)
+        else:
+            sublime.message_dialog("No classes could be found. Check your %s project setting." % self.setting_name)
 
     def _scan_dir(self, base, classname_to_find=None):
         return []
diff --git a/sublimejava.py b/sublimejava.py
@@ -158,9 +158,7 @@ def do_import(index):
             if index != -1:
                 self._insert_import(imports[index], edit)
 
-        if len(imports) == 1:
-            do_import(0)
-        elif len(imports) > 1:
+        if len(imports) > 0:
             view.window().show_quick_panel(imports, do_import)
         else:
             sublime.error_message("No classes found to import for name %s" % classname)

Original file line number	Diff line number	Diff line change
`@@ -282,7 +282,6 @@ private static boolean isPackage(String packageName)`
`282`	`282`	`return false;`
`283`	`283`	`}`
`284`	`284`
`285`		`- private static Map<String, Set<String>> importMap = new HashMap<String, Set<String>>();`
`286`	`285`	`private static final String CLASS_NAME_RE = "(?:$\|.)?(\\w+).class";`
`287`	`286`	`private static final String DIGITS_CLASS_NAME_RE = "\\d+";`
`288`	`287`	`private static final String SUBLIME_JAVA_CLASS_RE = "SublimeJava";`
`@@ -295,27 +294,24 @@ private static boolean isPackage(String packageName)`
`295`	`294`	`sublimeJavaClassPattern = Pattern.compile(SUBLIME_JAVA_CLASS_RE);`
`296`	`295`	`}`
`297`	`296`
`298`		`- private static void addToImportMap(String classFileName)`
	`297`	`+ private static String getImport(String classFileName, String searchClass)`
`299`	`298`	`{`
`300`	`299`	`Matcher classnameMatcher = classnamePattern.matcher(classFileName);`
`301`	`300`	`if (classnameMatcher.find())`
`302`	`301`	`{`
`303`	`302`	`String classname = classnameMatcher.group(1);`
`304`		`- Matcher digitsClassnameMatcher = digitsClassnamePattern.matcher(classname);`
`305`		`- if (!digitsClassnameMatcher.find())`
	`303`	`+ if ((searchClass != null && searchClass.equals(classname)) \|\|`
	`304`	`+ (searchClass == null && !digitsClassnamePattern.matcher(classname).matches()))`
`306`	`305`	`{`
`307`		`- if (!importMap.containsKey(classname))`
`308`		`- {`
`309`		`- importMap.put(classname, new HashSet<String>());`
`310`		`- }`
`311`	`306`	`String fullClassname = classFileName.replace("/", ".").replace(".class", "");`
`312`	`307`	`if (fullClassname.startsWith("."))`
`313`	`308`	`{`
`314`	`309`	`fullClassname = fullClassname.substring(1);`
`315`	`310`	`}`
`316`		`- importMap.get(classname).add(fullClassname);`
	`311`	`+ return fullClassname;`
`317`	`312`	`}`
`318`	`313`	`}`
	`314`	`+ return null;`
`319`	`315`	`}`
`320`	`316`
`321`	`317`	`private static String[] getClasspathEntries()`
`@@ -356,90 +352,65 @@ private static URL getUrlFromClasspathEntry(ClassLoader classLoader, String clas`
`356`	`352`	`return url;`
`357`	`353`	`}`
`358`	`354`
`359`		`- private static Set<File> getClassFilesNotInJar(File current)`
	`355`	`+ private static void printImportsNotInJar(File current, File root, String classname, Set<String> possibleImports)`
`360`	`356`	`{`
`361`		`- Set<File> classFiles = new HashSet<File>();`
`362`		`- if (current.isFile() && current.getName().endsWith(".class"))`
	`357`	`+ Matcher classnameMatcher = classnamePattern.matcher(current.getName());`
	`358`	`+ if (current.isFile() && classnameMatcher.matches())`
`363`	`359`	`{`
`364`		`- classFiles.add(current);`
	`360`	`+ if (classname == null \|\| classname.equals(classnameMatcher.group(1)))`
	`361`	`+ {`
	`362`	`+ String classFileName = current.getAbsolutePath().substring(root.getAbsolutePath().length());`
	`363`	`+ printPossibleImport(getImport(classFileName, classname), possibleImports);`
	`364`	`+ }`
`365`	`365`	`}`
`366`	`366`	`else if (current.isDirectory())`
`367`	`367`	`{`
`368`	`368`	`for (File file : current.listFiles())`
`369`	`369`	`{`
`370`		`- classFiles.addAll(getClassFilesNotInJar(file));`
	`370`	`+ printImportsNotInJar(file, root, classname, possibleImports);`
`371`	`371`	`}`
`372`	`372`	`}`
`373`		`- return classFiles;`
`374`	`373`	`}`
`375`	`374`
`376`	`375`	`private static void getPossibleImports(String classname)`
`377`	`376`	`throws IOException`
`378`	`377`	`{`
`379`		`- boolean importMapPopulated = importMap.size() > 0;`
`380`		`-`
`381`		`- if (!importMapPopulated)`
	`378`	`+ Set<String> possibleImports = new HashSet<String>();`
	`379`	`+ ClassLoader classLoader = Thread.currentThread().getContextClassLoader();`
	`380`	`+ for (String s : getClasspathEntries())`
`382`	`381`	`{`
`383`		`- ClassLoader classLoader = Thread.currentThread().getContextClassLoader();`
`384`		`- for (String s : getClasspathEntries())`
	`382`	`+ URL url = getUrlFromClasspathEntry(classLoader, s, "");`
	`383`	`+ if (url == null)`
	`384`	`+ continue;`
	`385`	`+ System.err.println("s: " + s);`
	`386`	`+ System.err.println("url: " + url);`
	`387`	`+`
	`388`	`+ String filename = URLDecoder.decode(url.getFile(), "UTF-8");`
	`389`	`+ if (url.getProtocol().equals("jar"))`
`385`	`390`	`{`
`386`		`- URL url = getUrlFromClasspathEntry(classLoader, s, "");`
`387`		`- if (url == null)`
`388`		`- continue;`
`389`		`- System.err.println("s: " + s);`
`390`		`- System.err.println("url: " + url);`
	`391`	`+ filename = filename.substring(5, filename.indexOf("!"));`
`391`	`392`
`392`		`- String filename = URLDecoder.decode(url.getFile(), "UTF-8");`
`393`		`- if (url.getProtocol().equals("jar"))`
	`393`	`+ JarFile jf = new JarFile(filename);`
	`394`	`+ Enumeration<JarEntry> entries = jf.entries();`
	`395`	`+ while (entries.hasMoreElements())`
`394`	`396`	`{`
`395`		`- filename = filename.substring(5, filename.indexOf("!"));`
	`397`	`+ String imp = getImport(entries.nextElement().getName(), classname);`
	`398`	`+ printPossibleImport(imp, possibleImports);`
`396`	`399`
`397`		`- JarFile jf = new JarFile(filename);`
`398`		`- Enumeration<JarEntry> entries = jf.entries();`
`399`		`- while (entries.hasMoreElements())`
`400`		`- {`
`401`		`- addToImportMap(entries.nextElement().getName());`
`402`		`- }`
`403`		`- }`
`404`		`- else`
`405`		`- {`
`406`		`- File folder = new File(filename);`
`407`		`- File[] classFiles = getClassFilesNotInJar(folder).toArray(new File[0]);`
`408`		`- for (File classFile : classFiles)`
`409`		`- {`
`410`		`- addToImportMap(classFile.getAbsolutePath().substring(folder.getAbsolutePath().length()));`
`411`		`- }`
`412`	`400`	`}`
`413`	`401`	`}`
`414`		`- }`
`415`		`-`
`416`		`- if (classname != null)`
`417`		`- {`
`418`		`- Set<String> possibleImports = importMap.get(classname);`
`419`		`- if (possibleImports != null)`
`420`		`- {`
`421`		`- printImports(possibleImports);`
`422`		`- }`
`423`		`- }`
`424`		`- else`
`425`		`- {`
`426`		`- for (Set<String> imports : importMap.values())`
	`402`	`+ else`
`427`	`403`	`{`
`428`		`- printImports(imports);`
	`404`	`+ File folder = new File(filename);`
	`405`	`+ printImportsNotInJar(folder, folder, classname, possibleImports);`
`429`	`406`	`}`
`430`	`407`	`}`
`431`		`-`
`432`	`408`	`}`
`433`	`409`
`434`		`- private static void printImports(Set<String> imports)`
	`410`	`+ private static void printPossibleImport(String fullClassname, Set<String> possibleImports)`
`435`	`411`	`{`
`436`		`- for (String impClass : imports)`
`437`		`- {`
`438`		`- if (!sublimeJavaClassPattern.matcher(impClass).matches())`
`439`		`- {`
`440`		`- System.out.println(impClass);`
`441`		`- }`
`442`		`- }`
	`412`	`+ if (fullClassname != null && possibleImports.add(fullClassname))`
	`413`	`+ System.out.println(fullClassname);`
`443`	`414`	`}`
`444`	`415`
`445`	`416`	`private static void completePackage(String packageName)`
`@@ -588,7 +559,7 @@ else if (args[0].equals("-findclass"))`
`588`	`559`	`for (String pack : packages)`
`589`	`560`	`{`
`590`	`561`	`String classname = getClassname(pack, args[1]);`
`591`		`- while (!found && classname.indexOf('.') != -1)`
	`562`	`+ while (!found && classname != null && classname.indexOf('.') != -1)`
`592`	`563`	`{`
`593`	`564`	`int idx = classname.lastIndexOf('.');`
`594`	`565`	`classname = classname.substring(0, idx) + "$" + classname.substring(idx+1);`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,4 @@`
`1`	`1`	`[`
`2`		`- {`
`3`		`- "caption": "Java: Import Class",`
`4`		`- "command": "import_java_class"`
`5`		`- },`
`6`	`2`	`{`
`7`	`3`	`"caption": "Java: Import Class Under Cursor",`
`8`	`4`	`"command": "import_java_class",`