Application: gvSIG desktop » gvSIG scripting

package org.gvsig.scripting.impl;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.Writer;

import java.net.MalformedURLException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import javax.script.ScriptContext;

import javax.script.ScriptEngine;

import javax.script.ScriptEngineFactory;

import javax.script.ScriptEngineManager;

import javax.script.SimpleBindings;

import javax.swing.ImageIcon;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.scripting.ScriptingBaseScript;

import org.gvsig.scripting.ScriptingDialog;

import org.gvsig.scripting.ScriptingFolder;

import org.gvsig.scripting.ScriptingHelpManager;

import org.gvsig.scripting.ScriptingManager;

import org.gvsig.scripting.ScriptingProject;

import org.gvsig.scripting.ScriptingScript;

import org.gvsig.scripting.ScriptingUnit;

public class DefaultScriptingManager implements ScriptingManager{

    private static final Logger LOG = LoggerFactory

        .getLogger(DefaultScriptingManager.class);

        protected String rootUserFolder;

    protected Map<String, ImageIcon> icons;

        protected List<RegisterSystemFolder> systemFolders = new ArrayList<RegisterSystemFolder>();

        protected ScriptEngineManager engineManager = null;

        private final SimpleBindings bindings = new SimpleBindings();

        private final ScriptingHelpManager helpManager;

        private List<String> unitTypes = null;

    private ClassLoader classLoader = null;

    public DefaultScriptingManager() {

        this.helpManager = new DefaultScriptingHelpManager(this);

        initialize();

        this.classLoader = getClass().getClassLoader();

    }

    public DefaultScriptingManager(ClassLoader classLoader) {

        this();

        this.classLoader = classLoader;

    }

    private void initialize() {

        this.rootUserFolder =

            System.getProperty("user.home") + File.separator + "scripts";

        File f =

            new File(System.getProperty("user.dir") + File.separator + ".."

                + File.separator + "org.gvsig.scripting.lib" + File.separator

                + "org.gvsig.scripting.lib.api" + File.separator + "target"

                + File.separator + "site" + File.separator + "apidoc");

        if (f.exists()) {

            try {

                this.helpManager.importHelp("ScriptingFrameworkHelp", f.toURI()

                    .toURL());

            } catch (MalformedURLException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

        }

        this.bindings.put("ScriptingManager", this);

    }

        protected ScriptEngineManager getEngineManager(){

                if(this.engineManager == null){

            this.engineManager =

                classLoader == null ? new ScriptEngineManager()

                    : new ScriptEngineManager(classLoader);

            showEnginesInfo(engineManager);

                }

                return this.engineManager;

        }

    private void showEnginesInfo(ScriptEngineManager mgr) {

        if (LOG.isInfoEnabled()) {

            List<ScriptEngineFactory> factories = mgr.getEngineFactories();

            StringBuffer buffer = new StringBuffer();

            List<Object> values = new ArrayList<Object>();

            buffer.append("Scripting engines available:");

            for (ScriptEngineFactory factory : factories) {

                // Main engine info

                buffer

                    .append("\n- {}: version = {}, language = {}, langVersion = {}");

                values.add(factory.getEngineName());

                values.add(factory.getEngineVersion());

                values.add(factory.getLanguageName());

                values.add(factory.getLanguageVersion());

                // Aliases

                buffer.append("\n\t- Aliases: ");

                List<String> engNames = factory.getNames();

                int size = engNames.size();

                for (String name : engNames) {

                    size--;

                    buffer.append("{}");

                    if (size > 0) {

                        buffer.append(", ");

                    }

                    values.add(name);

                }

                buffer.append("\n\t- File extensions: ");

                List<String> extNames = factory.getExtensions();

                size = extNames.size();

                for (String name : extNames) {

                    size--;

                    buffer.append("{}");

                    if (size > 0) {

                        buffer.append(", ");

                    }

                    values.add(name);

                }

                buffer.append("\n\t- Mime types: ");

                List<String> mimeNames = factory.getMimeTypes();

                size = mimeNames.size();

                for (String name : mimeNames) {

                    size--;

                    buffer.append("{}");

                    if (size > 0) {

                        buffer.append(", ");

                    }

                    values.add(name);

                }

            }

            LOG.info(buffer.toString(), values.toArray());

        }

    }

    protected ScriptEngine getEngine(String langName) {

                ScriptEngine engine = this.getEngineManager().getEngineByName(langName);

                engine.getBindings(ScriptContext.ENGINE_SCOPE).putAll(bindings);

                return engine;

        }

        public ImageIcon getIcon(String name){

                return this.icons.get(name);

        }

        public Map<String,String> getSupportedLanguagesByExtension(){

        List<ScriptEngineFactory> factories =

            getEngineManager().getEngineFactories();

        Map<String, String> extToLang = new HashMap<String, String>();

        for (ScriptEngineFactory factory : factories) {

            List<String> extNames = factory.getExtensions();

            for (String name : extNames) {

                extToLang.put(".".concat(name), factory.getLanguageName());

            }

        }

        return extToLang;

        }

        public Map<String, String> getExtensionsByLanguages(){

        Map<String, String> l = getSupportedLanguagesByExtension();

                Map<String,String> result = new HashMap<String,String>();

        Iterator<Map.Entry<String, String>> it = l.entrySet().iterator();

            while (it.hasNext()) {

            Map.Entry<String, String> pairs = it.next();

            result.put(pairs.getValue(), pairs.getKey());

            }

                return result;

        }

        public boolean validateUnitId(ScriptingFolder folder, String id){

        List<ScriptingUnit> units = folder.getUnits();

                String fileName;

                String s[];

                String extension;

                for(int i=0; i<units.size();i++){

                        fileName = (units.get(i)).getId();

                        s = fileName.split("\\.");

                        extension = null;

                        if (s.length>1){

                                extension ="." +  s[s.length-1];

                                fileName = fileName.substring(0,fileName.length()-extension.length());

                        }

                        if(fileName.equals(id)){

                                return false;

                        }

                }

                return true;

        }

        public static String getStringFromFile(String filename){

                BufferedReader b = null;

                try {

                        b = new BufferedReader(new FileReader(filename));

                } catch (FileNotFoundException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

                StringBuffer sb=new StringBuffer();

                String str;

                try {

                        while((str=b.readLine())!=null) {

                                sb.append(str);

                                sb.append('\n');

                        }

                } catch (IOException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

                return sb.toString();

        }

        public ScriptingDialog createDialog(ScriptingFolder folder, String id) {

                DefaultScriptingDialog sd = new DefaultScriptingDialog(this);

                sd.setId(id);

                File file = new File(((DefaultScriptingFolder)folder).getPath()+File.separator+id);

                try {

                        file.createNewFile();

                } catch (IOException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

                // Eliminamos la extensión, para crear el '.dlg'

                String s[] = id.split("\\.");

                String newId;

                if (s.length>=2){

                        String extension ="." +  s[s.length-1];

                        newId = id.substring(0,id.length()-extension.length());

                }else{

                        newId = id;

                }

                File fileDlg = new File(((DefaultScriptingFolder)folder).getPath()+File.separator+newId+".dlg");

                try {

                        fileDlg.createNewFile();

                } catch (IOException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

                // Escribimos en el fichero '.dlg' lo mínimo para que pueda ejecutarse

            Writer output = null; 

            try {

                        output = new BufferedWriter(new FileWriter(fileDlg));

                        output.write("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n<panel/>");

                        output.close();

                } catch (IOException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

                sd.load(folder, id);

                return sd;

        }

        public ScriptingFolder createFolder(ScriptingFolder folder, String id) {

                DefaultScriptingFolder fd = new DefaultScriptingFolder(this);

                File dir = new File(((DefaultScriptingFolder)folder).getPath()+File.separator+id);

                dir.mkdir();

                fd.load(folder,id);

                return fd;

        }

        public ScriptingProject createProject(ScriptingFolder folder, String id) {

                // TODO Auto-generated method stub

                return null;

        }

        public ScriptingScript createScript(ScriptingFolder folder, String id) {

                DefaultScriptingScript sc = new DefaultScriptingScript(this);

                sc.setId(id);

                File file = new File(((DefaultScriptingFolder)folder).getPath()+File.separator+id);

                try {

                        file.createNewFile();

                } catch (IOException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                        return null;

                }

                sc.load(folder, id);

                return sc;

        }

        public ScriptingBaseScript getScript(File file) {

                ScriptingBaseScript script = (ScriptingBaseScript) this.getUnit(file);

                if (script == null){

                        throw new RuntimeException(file.getPath());

                }

                return script;

        }

        public ScriptingFolder getFolder(File file) {

                ScriptingFolder folder = (ScriptingFolder) this.getUnit(file);

                if (folder == null){

                        throw new RuntimeException(file.getAbsolutePath());

                }

                return folder;

        }

        public ScriptingUnit getUnit(File file) {

                ScriptingFolder folder = null;

                ScriptingUnit unit = null;

                folder = this.getUserFolder();

                unit = folder.getUnit(file);

                if( unit != null ) {

                        return unit;

                }

                folder = this.getSystemFolder();

                unit = folder.getUnit(file);

                if( unit != null ) {

                        return unit;

                }

                return null;

        }

        public ScriptingFolder getSystemFolder() {

                return new SystemFolder(this);

        }

        public ScriptingFolder getUserFolder() {

                return new UserFolder(this,new File(this.getRootUserFolder()));

        }

        public String getRootUserFolder() {

                return this.rootUserFolder;

        }

        public void setRootUserFolder(String path){

                this.rootUserFolder = path;

        }

        public void registerSystemFolder(String name, File folder) {

                this.systemFolders.add(new RegisterSystemFolder(name, folder));

        }

        public List<RegisterSystemFolder> getSystemFolders(){

                return this.systemFolders;

        }

        public static class RegisterSystemFolder {

                public String name;

                public File folder;

                public RegisterSystemFolder(String name, File folder) {

                        this.name = name;

                        this.folder = folder;

                }

        }

        public String getExtensionByLanguage(String langName) {

        Map<String, String> extensions = getSupportedLanguagesByExtension();

        Iterator<String> iterator = extensions.keySet().iterator();

                String extension = null;

                String s = null;

                while (iterator. hasNext()){

                        extension = iterator.next();

                        s = extensions.get(extension);

            if (s.equalsIgnoreCase(langName)) {

                                return extension;

                        }

                }

                return null;

        }

        public Object get(String key) {

                return this.bindings.get(key);

        }

        public void put(String key, Object value) {

                this.bindings.put(key,value); 

        }

        public ScriptingHelpManager getHelpManager() {

                return this.helpManager;

        }

        public ScriptingUnit createUnit(String unitType, ScriptingFolder folder, String id) {

                if(unitType.equals(UNIT_SCRIPT)){

                        return this.createScript(folder, id);

                }

                if(unitType.equals(UNIT_DIALOG)){

                        return this.createDialog(folder, id);

                }

                if(unitType.equals(UNIT_FOLDER)){

                        return this.createFolder(folder, id);

                }

                if(unitType.equals(UNIT_PROJECT)){

                        return null;

                }

                return null;

        }

        public List<String> getUnitTypes() {

                if(this.unitTypes==null){

                        this.unitTypes=new ArrayList<String>();

                        this.unitTypes.add(UNIT_SCRIPT);

                        this.unitTypes.add(UNIT_DIALOG);

                        this.unitTypes.add(UNIT_PROJECT);

                        this.unitTypes.add(UNIT_FOLDER);

                }

                return this.unitTypes;

        }

}