Application: gvSIG desktop » gvSIG scripting

package org.gvsig.scripting.impl;

import java.io.File;

import java.io.IOException;

import java.net.URL;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.logging.Level;

import java.util.logging.Logger;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.apache.commons.io.FileUtils;

import org.gvsig.scripting.ScriptingHelpManager.ScriptingHelpClass;

import org.gvsig.scripting.ScriptingHelpManager.ScriptingHelpMethod;

public class MethodList extends ArrayList<ScriptingHelpMethod> {

    /**

     *

     */

    private static final long serialVersionUID = 2097121200002178537L;

    private Map<String, ClassNode> allClasses = new HashMap<String, ClassNode>();

    public MethodList() {

    }

    public void addMethods(URL indexFileUrl) {

        File f = new File(indexFileUrl.getFile());      

        this.addMethods(f);

    }

    public void addMethods(File index) {

        String indexFile = null;

        try {

            indexFile = FileUtils.readFileToString(index);

        } catch (IOException ex) {

        }

        Pattern methodPattern = Pattern.compile("<indexitem text=\"[^\"]*\" expand=\"false\">");

        Pattern endMethodPattern = Pattern.compile("</indexitem>");;

        Pattern classPattern = Pattern.compile("<indexitem text=\"[^\"]*\" target=\"[^\"]*\" />");

        Matcher methodMatcher = methodPattern.matcher(indexFile);

        while (methodMatcher.find()) {

            String subIndexFile = indexFile.substring(methodMatcher.start());

            Matcher endMethodMatcher = endMethodPattern.matcher(subIndexFile);

            if (endMethodMatcher.find()) {

                String methodExtract = subIndexFile.substring(0, endMethodMatcher.start());

                String[] methodnode = (indexFile.substring(methodMatcher.start(), methodMatcher.end())).split("\"");

                if (methodnode.length > 2) {

                    MethodNode mn = new MethodNode(methodnode[1], null);

                    Matcher classMatcher = classPattern.matcher(methodExtract);

                    while (classMatcher.find()) {

                        String[] classnode = (methodExtract.substring(classMatcher.start(), classMatcher.end())).split("\"");

                        if (classnode.length > 3) {

                            ClassNode cn = this.getOrCreateClassInfo(classnode[1], classnode[3]);

                            cn.addMethod(mn.getName());

                            mn.add(cn);

                        }

                    }

                    this.add(mn);

                }

            }

        }

    }

    private ClassNode getOrCreateClassInfo(String name, String url) {

        ClassNode cn = this.allClasses.get(name);

        if( cn == null ) {

            cn = new ClassNode(name,url);

            this.allClasses.put(name,cn);

        }

        return cn;

    }

    public ClassNode getHelpClass(String name) {

        return this.allClasses.get(name);

    }

    public List<ScriptingHelpClass> getHelpClasses(){

        List<ScriptingHelpClass> classes = new ArrayList<ScriptingHelpClass>(this.allClasses.values());

        Collections.sort(classes);

        return classes;

    }

    public ScriptingHelpClass add(String className, String target, List<String> methods) {

        ClassNode cn = this.getOrCreateClassInfo(className, target);

        for (String methodName : methods) {

            boolean isFound = false;

            for (ScriptingHelpMethod mn : this) {

                if (mn.getName().equals(methodName)) {

                    ((MethodNode) mn).add(cn);

                    cn.addMethod(((MethodNode) mn).getName());

                    isFound = true;

                }

            }

            if (!isFound) {

                this.add(new MethodNode(methodName, cn));

            }

        }

        Collections.sort(this, new Comparator<ScriptingHelpMethod>() {

            public int compare(ScriptingHelpMethod p1, ScriptingHelpMethod p2) {

                return p1.getName().toLowerCase().compareTo(p2.getName().toLowerCase());

            }

        });

        return cn;

    }

    public void printMethodList(Map<String, MethodNode> map) {

        Set<String> keys = map.keySet();

        Iterator<String> it = keys.iterator();

        while (it.hasNext()) {

            MethodNode mn = map.get(it.next());

            Iterator<ScriptingHelpClass> i = mn.iterator();

            System.out.println(mn);

            while (i.hasNext()) {

                ClassNode cn = (ClassNode) i.next();

                System.out.println(" ->" + cn.className);

            }

        }

    }

    public Map<String, ScriptingHelpMethod> findMethods(String text) {

        Map<String, ScriptingHelpMethod> matches = new HashMap<String, ScriptingHelpMethod>();

        List<ScriptingHelpMethod> l = this;

        if (text != null) {

            for (ScriptingHelpMethod mn : l) {

                if (mn.getName().toLowerCase().contains(text.toLowerCase())) {

                    matches.put(mn.getName(), mn);

                }

            }

        }

        return matches;

    }

    private static class MethodNode implements ScriptingHelpMethod {

        /**

         *

         */

        private static final long serialVersionUID = -7155323542211180518L;

        private final String methodName;

        private final List<ScriptingHelpClass> classes;

        MethodNode(String name, ScriptingHelpClass c) {

            this.methodName = name;

            this.classes = new ArrayList<ScriptingHelpClass>();

            if (c != null) {

                classes.add(c);

            }

        }

        MethodNode add(ClassNode c) {

            this.classes.add(c);

            return this;

        }

        public String getName() {

            return this.methodName;

        }

        public Iterator<ScriptingHelpClass> iterator() {

            return this.classes.iterator();

        }

        public String toString() {

            return getName();

        }

    }

    private static class ClassNode implements ScriptingHelpClass, Comparable {

        String className;

        String classUrl;

        Set<String> methods = new HashSet<String>();

        ClassNode(String name, String url) {

            this.className = name;

            this.classUrl = url;

        }

        public String getName() {

            return this.className;

        }

        public String getUrl() {

            return this.classUrl;

        }

        public String toString() {

            return getName();

        }

        public void addMethod(String name) {

            this.methods.add(name);

        }

        public List<String> getMethods() {

            List l = new ArrayList(this.methods);

            Collections.sort(l);

            return l;

        }

        @Override

        public int compareTo(Object o) {

            return this.className.compareToIgnoreCase( ((ClassNode)o).getName() );

        }

    }

//    public ScriptingHelpClass createHelpClass(String name, String target) {

//        return new ClassNode(name, target);

//    }

}