IssueZilla 11104 - Add -language command line option, and automatic parcel

descriptor generation

scripting/java/org/openoffice/idesupport/JavaFinder.java

@@ -0,0 +1,199 @@
+package org.openoffice.idesupport;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Vector;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.net.MalformedURLException;
+import org.openoffice.idesupport.zip.ParcelZipper;
+
+public class JavaFinder implements MethodFinder {
+
+    private static JavaFinder finder;
+    private static final String JAVA_SUFFIX = ".java";
+    private static final String CLASS_SUFFIX = ".class";
+    private static final String LANGUAGE = "Java";
+    private static final String FIRST_PARAM =
+        "drafts.com.sun.star.script.framework.XScriptContext";
+
+    private Vector classpath = null;
+
+    private JavaFinder() {}
+
+    private JavaFinder(Vector classpath) {
+        this.classpath = classpath;
+    }
+
+    public static JavaFinder getInstance() {
+        if (finder == null) {
+            synchronized(JavaFinder.class) {
+                if (finder == null)
+                    finder = new JavaFinder();
+            }
+        }
+        return finder;
+    }
+
+    public static JavaFinder getInstance(Vector classpath) {
+        return new JavaFinder(classpath);
+    }
+
+    public ScriptEntry[] findMethods(File basedir) {
+        String parcelName;
+        ArrayList result = new ArrayList(10);
+        ScriptEntry[] empty = new ScriptEntry[0];
+
+        if (basedir == null || basedir.exists() == false ||
+            basedir.isDirectory() == false)
+            return empty;
+
+        parcelName = basedir.getName();
+        if (parcelName.equals(ParcelZipper.CONTENTS_DIRNAME))
+            parcelName = basedir.getParentFile().getName();
+
+        String[] classNames = findClassNames(basedir);
+        if (classNames != null && classNames.length != 0) {
+
+            ClassLoader classloader;
+
+            if (classpath == null)
+                classloader = getClassLoader(basedir.getAbsolutePath());
+            else
+                classloader = getClassLoader();
+
+            for (int i = 0; i < classNames.length; i++)
+            {
+                try
+                {
+                    Class clazz = classloader.loadClass(classNames[i]);
+                    Method[] methods = clazz.getDeclaredMethods();
+                    for (int k = 0; k < methods.length; k++)
+                    {
+                        if (Modifier.isPublic(methods[k].getModifiers()))
+                        {
+                            Class[] params = methods[k].getParameterTypes();
+                            if(params.length > 0)
+                            {
+                                if(params[0].getName().equals(FIRST_PARAM))
+                                {
+                                    ScriptEntry entry =
+                                        new ScriptEntry(classNames[i] + "." +
+                                            methods[k].getName(), parcelName);
+                                    result.add(entry);
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (ClassNotFoundException e)
+                {
+                    System.err.println("Caught ClassNotFoundException loading: "
+                        + classNames[i]);
+                    continue;
+                }
+                catch (NoClassDefFoundError nc)
+                {
+                    System.err.println("Caught NoClassDefFoundErr loading: " +
+                        classNames[i]);
+                    continue;
+                }
+            }
+        }
+
+        if (result.size() != 0)
+            return (ScriptEntry[])result.toArray(empty);
+        return empty;
+    }
+
+    private ClassLoader getClassLoader() {
+        int len = classpath.size();
+        ArrayList urls = new ArrayList(len);
+
+        for (int i = 0; i < len; i++) {
+            try {
+                String s = (String)classpath.elementAt(i);
+                s = SVersionRCFile.toFileURL(s);
+
+                if (s != null)
+                    urls.add(new URL(s));
+            }
+            catch (MalformedURLException mue) {
+            }
+        }
+
+        return new URLClassLoader((URL[])urls.toArray(new URL[0]));
+    }
+
+    private ClassLoader getClassLoader(String path) {
+        URL[] urls = new URL[1];
+
+        try {
+            path = SVersionRCFile.toFileURL(path);
+
+            if (path != null)
+                urls[0] = new URL(path);
+        }
+        catch (MalformedURLException mue) {
+            return null;
+        }
+
+        return new URLClassLoader(urls);
+    }
+
+    private ArrayList findFiles(File basedir, String suffix) {
+        ArrayList result = new ArrayList();
+        File[] children = basedir.listFiles();
+
+        for (int i = 0; i < children.length; i++) {
+            if (children[i].isDirectory())
+                result.addAll(findFiles(children[i], suffix));
+            else if (children[i].getName().endsWith(suffix))
+                result.add(children[i]);
+        }
+        return result;
+    }
+
+    private String[] findClassNames(File basedir)
+    {
+        ArrayList classFiles = findFiles(basedir, CLASS_SUFFIX);
+        if(classFiles == null || classFiles.size() == 0)
+            return null;
+
+        ArrayList javaFiles = findFiles(basedir, JAVA_SUFFIX);
+        if(javaFiles == null || javaFiles.size() == 0)
+            return null;
+
+        ArrayList result = new ArrayList();
+        for (int i = 0; i < classFiles.size(); i++)
+        {
+            File classFile = (File)classFiles.get(i);
+            String className = classFile.getName();
+            className = className.substring(0, className.lastIndexOf(CLASS_SUFFIX));
+            boolean finished = false;
+
+
+            for (int j = 0; j < javaFiles.size() && finished == false; j++)
+            {
+                File javaFile = (File)javaFiles.get(j);
+                String javaName = javaFile.getName();
+                javaName = javaName.substring(0, javaName.lastIndexOf(JAVA_SUFFIX));
+
+                if (javaName.equals(className))
+                {
+                    String path = classFile.getAbsolutePath();
+                    path = path.substring(basedir.getAbsolutePath().length() + 1);
+                    path = path.replace(File.separatorChar, '.');
+                    path = path.substring(0, path.lastIndexOf(CLASS_SUFFIX));
+
+                    result.add(path);
+                    javaFiles.remove(j);
+                    finished = true;
+                }
+            }
+        }
+        return (String[])result.toArray(new String[0]);
+    }
+}