Application: gvSIG desktop » gvSIG scripting

package org.gvsig.scripting.impl;

import java.io.File;

import java.net.URL;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.gvsig.scripting.ScriptingHelpManager.ScriptingHelpClass;

import org.gvsig.scripting.ScriptingHelpManager.ScriptingHelpMethod;

public class MethodList extends ArrayList<ScriptingHelpMethod>  {

        /**

         * 

         */

        private static final long serialVersionUID = 2097121200002178537L;

        public MethodList() {

        }

        public void addMethods(URL indexFileUrl){

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

                String indexFile = DefaultScriptingManager.getStringFromFile(f.getPath());

                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 = new ClassNode(classnode[1],classnode[3]);

                                                        mn.add(cn);

                                                }

                                        }

                                        this.add(mn);

                                }

                        }

                }

        }

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

            ClassNode cn = new ClassNode(className,target);

            for (String methodName : methods) {

                        boolean isFound=false;

                        for (ScriptingHelpMethod mn : this) {

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

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

                                        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();

                }

        }

        private static  class ClassNode implements ScriptingHelpClass{

                String className;

                String classUrl;

                ClassNode(String name, String url){

                        this.className = name;

                        this.classUrl = url;

                }

                public String getName(){

                        return this.className;

                }

                public String getUrl(){

                        return this.classUrl;

                }

        }

        public ScriptingHelpClass createHelpClass(String name, String target) {

                return new ClassNode(name, target);

        }

}