Application: gvSIG desktop » gvSIG scripting

package org.gvsig.scripting.impl;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.IOException;

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.apache.commons.io.FileUtils;

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;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultScriptingManager implements ScriptingManager{

    private static final Logger LOG = LoggerFactory

        .getLogger(DefaultScriptingManager.class);

    protected Map<String, ImageIcon> icons;

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

        protected ScriptEngineManager engineManager = null;

        private final SimpleBindings bindings = new SimpleBindings();

        private ScriptingHelpManager helpManager = null;

        private List<String> unitTypes = null;

    private ClassLoader classLoader = null;

    private List<File> libFolders = new ArrayList<File>();

    private File home = null;

    public DefaultScriptingManager() {

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

        this.setHomeFolder(null);

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

    }

    public DefaultScriptingManager(ClassLoader classLoader) {

        this();

        this.classLoader = classLoader;

    }

    private void createFolder(File f){

            if( !f.exists() ) {

                        try {

                                FileUtils.forceMkdir(f);

                                LOG.info("Created scripting folder '"+f.getAbsolutePath()+"'");

                        } catch (Throwable e) {

                                LOG.warn("Can't Create scripting folder '"+f.getAbsolutePath()+"'");

                        }

            }

    }

    private void createDefaultFolders(File home) {

            createFolder(new File(home,"scripts"));

            createFolder(new File(home,"help"));

            createFolder(new File(home,"lib"));

    }

    public File getHomeFolder() {

            if( !this.home.exists() ) {

                    createFolder(home);

                    createDefaultFolders(home);

            }

            return this.home;

    }

    public void setHomeFolder(File home) {

            if( home == null ) {

                    this.home = new File(System.getProperty("user.home"), ".gvsig-scripting");

            } else {

                    this.home = home;

            }

            createDefaultFolders(this.home);

                LOG.info("Set scripting home to '"+this.home.getAbsolutePath()+"'");

                this.addLibFolder(new File(this.home,"lib"));

    }

        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 {

                        try {

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

                        } catch (FileNotFoundException e) {

                                LOG.warn("Can't open file '"+filename+"'.",e);

                        }

                        StringBuffer sb=new StringBuffer();

                        String str;

                        try {

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

                                        sb.append(str);

                                        sb.append('\n');

                                }

                        } catch (IOException e) {

                                LOG.warn("Can't read file '"+filename+"'.",e);

                        }

                        return sb.toString();

                } finally {

                        if( b!=null ) {

                                try {

                                        b.close();

                                } catch (IOException e) {

                                        LOG.warn("Can't close file '"+filename+"'", e);

                                }

                                b = null;

                        }

                }

        }

        public ScriptingScript createScript(ScriptingFolder folder, String id) {

                return this.createScript(folder, id, null);

        }

        private ScriptingScript createScript(ScriptingFolder folder, String id, String language) {

                DefaultScriptingScript script = new DefaultScriptingScript(folder, this, id);

                if( !script.getFile().exists() ) {

                        script.create(folder, id, language);

                } else {

                        script.load(folder, id);

                }

                return script;

        }

        public ScriptingDialog createDialog(ScriptingFolder folder, String id) {

                return this.createDialog(folder, id, null);

        }

        private ScriptingDialog createDialog(ScriptingFolder folder, String id, String language) {

                DefaultScriptingDialog dialog = new DefaultScriptingDialog(folder, this, id);

                if( !dialog.getFile().exists() ) {

                        dialog.create(folder, id, language);

                } else {

                        dialog.load(folder, id);

                }

                return dialog;

        }

        public ScriptingFolder createFolder(ScriptingFolder folder, String id) {

                DefaultScriptingFolder unit = new DefaultScriptingFolder(folder, this);

                if( !unit.getFile().exists() ) {

                        unit.create(folder, id);

                } else {

                        unit.load(folder,id);

                }

                return folder;

        }

        public ScriptingProject createProject(ScriptingFolder folder, String id) {

                LOG.warn("Projects can't be implementeds");

                return null;

        }

        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,this.getRootUserFolder());

        }

        public ScriptingBaseScript getScript(String name) {

                return (ScriptingBaseScript)findScript(null, name);

        }

        private ScriptingUnit findScript(ScriptingFolder folder, String name) {

                if( name==null ) {

                        return null;

                }

                if( name.trim().length()==0 ) {

                        return  null;

                }

                ScriptingUnit unit = null;

                if( folder == null ) {

                        unit = findScript(this.getUserFolder(), name);

                        if( unit != null ) {

                                return unit;

                        }

                        unit = findScript(this.getSystemFolder(), name);

                        return unit;

                }

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

                Iterator<ScriptingUnit> it = units.iterator();

                while( it.hasNext() ) {

                        unit = it.next();

                        if( unit instanceof ScriptingFolder ) {

                                unit = findScript((ScriptingFolder) unit, name);

                                if( unit!= null ) {

                                        return unit;

                                }

                        } else if( unit instanceof ScriptingBaseScript ) {

                                if( name.equalsIgnoreCase(unit.getId()))  {

                                        return unit;

                                }

                        }

                }

                return null;

        }

        public File getRootUserFolder() {

                return new File(this.getHomeFolder(),"scripts");

        }

        public void registerSystemFolder(String name, File folder) {

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

            LOG.info("Register system folder name '"+name+"' folder "+folder.getAbsolutePath()+"'");

        }

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

                if( this.helpManager == null ) {

                        this.helpManager = new DefaultScriptingHelpManager(this);

                }

                return this.helpManager;

        }

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

                return createUnit(unitType, folder, id, null);

        }

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

                if(unitType.equals(UNIT_SCRIPT)){

                        return this.createScript(folder, id, language);

                }

                if(unitType.equals(UNIT_DIALOG)){

                        return this.createDialog(folder, id, language);

                }

                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;

        }

        public void addLibFolder(File lib) {

                if( lib.exists() ) {

                        LOG.info("Add scripting lib folder '"+lib.getAbsolutePath()+"'");

                        this.libFolders.add(lib);

                } else {

                        LOG.info("Skip add scripting lib folder '"+lib.getAbsolutePath()+"', folder don't exist");

                }

        }

        public List<File> getLibFolders() {

                return this.libFolders;

        }

}