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;

    private List<ScriptingFolder> alternativeUserFolders = new ArrayList<ScriptingFolder>();

    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, new File(folder.getFile(), id));

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

            unit.create(folder, id);

        } else {

            unit.load(folder, id);

        }

        return unit;

    }

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

        }

        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;

        if (file.isAbsolute()) {

            folder = new DefaultScriptingFolder(null, this, file.getParentFile());

            unit = folder.getUnit(file);

            return unit;

        } else {

            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 List<ScriptingFolder> getAlternativeUserFolders() {

        return this.alternativeUserFolders;

    }

    public void addAlternativeUserFolder(File f, String name, String description) {

        UserFolder x = new UserFolder(this, f);

        x.setName(name); 

        x.setDescription(description);

        x.setId("UserFolder_"+this.alternativeUserFolders.size()+1);

        this.alternativeUserFolders.add(x);

    }

    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;

    }

}