Application: gvSIG desktop » gvSIG scripting

package org.gvsig.scripting.impl;

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Collections;

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

import org.gvsig.scripting.ScriptingBaseScript;

import org.gvsig.scripting.ScriptingDialog;

import org.gvsig.scripting.ScriptingExternalFile;

import org.gvsig.scripting.ScriptingFolder;

import org.gvsig.scripting.ScriptingHelpManager;

import org.gvsig.scripting.ScriptingManager;

import org.gvsig.scripting.ScriptingScript;

import org.gvsig.scripting.ScriptingUnit;

import org.gvsig.tools.script.Script;

import org.gvsig.tools.service.spi.ProviderFactory;

import org.python.jsr223.MyPyScriptEngine;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultScriptingManager implements ScriptingManager {

    public static class RegisterSystemFolder {

        public String name;

        public File folder;

        public RegisterSystemFolder(String name, File folder) {

            this.name = name;

            this.folder = folder;

        }

    }

    private static final Logger LOG = LoggerFactory

            .getLogger(DefaultScriptingManager.class);

    protected Map<String, ImageIcon> icons;

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

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

    private File home = null;

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

    private Map<String, String> extensionOfLanguage = null;

    private Map<String, String> languageOfExtension = null;

    private File packagesFolder;

    private final Map properties = new HashMap();

    public DefaultScriptingManager() {

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

        this.setHomeFolder(null);

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

    }

    public DefaultScriptingManager(ClassLoader classLoader) {

        this();

        this.classLoader = classLoader;

    }

    @Override

    public Object getProperty(Object key) {

        return properties.get(key);

    }

    @Override

    public void setProperty(Object key, Object val) {

        properties.put(key, val);

    }

    @Override

    public Map getExtendedProperties() {

        return properties;

    }

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

    }

    @Override

    public File getHomeFolder() {

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

            createFolder(home);

            createDefaultFolders(home);

        }

        return this.home;

    }

    @Override

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

            StringBuilder buffer = new StringBuilder();

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

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

        }

    }

    public void loadEngines() {

        this.getEngineManager();

    }

    private ScriptEngine getJythonEngine() {

        ScriptEngineFactory factory = this.getEngineFactoryByLanguage("python");

        ScriptEngine engine = new MyPyScriptEngine(factory);

        return engine;

    }

    public ImageIcon getIcon(String name) {

        return this.icons.get(name);

    }

    @Override

    public String getEngineNameByLanguage(String langName) {

        ScriptEngineFactory factory = this.getEngineFactoryByLanguage(langName);

        if( factory == null ) {

            return null;

        }

        return factory.getEngineName();

    }

    public ScriptEngine createEngineByLanguage(String langName) {

        return this.getEngineByLanguage(langName);

    }

    public ScriptEngine getEngineByLanguage(String langName) {

        ScriptEngine engine;

        if( "python".equalsIgnoreCase(langName) ) {

            engine = getJythonEngine();

        } else {

            ScriptEngineFactory factory = this.getEngineFactoryByLanguage(langName);

            if( factory == null ) {

                return null;

            }

            engine = factory.getScriptEngine();

        }

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

        return engine;

    }

    public ScriptEngineFactory getEngineFactoryByLanguage(String langName) {

        List<ScriptEngineFactory> factories

                = getEngineManager().getEngineFactories();

        for (ScriptEngineFactory factory : factories) {

            if (factory.getLanguageName().equalsIgnoreCase(langName)) {

                return factory;

            }

        }

        return null;

    }

    @Override

    public boolean validateUnitId(ScriptingFolder folder, String id) {

        File f = new File(folder.getFile(),id+".inf");

        if( f.exists() ) {

            return false;

        }

        return true;

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

//        String fileName;

//        for (ScriptingUnit unit : units) {

//            fileName = unit.getId();

//            fileName = FilenameUtils.getBaseName(fileName);

//            if (fileName.equals(id)) {

//                return false;

//            }

//        }

//        return true;

    }

    public ScriptingScript createScript(ScriptingFolder folder, String id) {

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

    }

    public Script createScript(String name, String code, String languaje) {

        ScriptingScript script = new DefaultScriptingScript(this.getUserFolder(), this, name);

        script.setCode(code);

        script.setSaved(true);

        return script;        

    }

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

        unit.load(folder, id);

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

            unit.create(folder, id);

        }

        return unit;

    }

    public ScriptingExternalFile createExternalFile(ScriptingFolder folder, String id) {

        DefaultScriptingExternalFile unit = new DefaultScriptingExternalFile(folder, this, id);

        return unit;

    }

    @Override

    public ScriptingBaseScript getScript(File file) {

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

        if (script == null) {

            throw new ScriptNotFoundException(file);

        }

        return script;

    }

    @Override

    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;

        ScriptingUnit unit;

        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;

    }

    @Override

    public ScriptingFolder getSystemFolder() {

        return new SystemFolder(this);

    }

    @Override

    public ScriptingFolder getUserFolder() {

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

    }

    @Override

    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;

        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;

    }

    @Override

    public File getRootUserFolder() {

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

    }

    @Override

    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;

    }

    @Override

    public List<ScriptingFolder> getAlternativeUserFolders() {

        return this.alternativeUserFolders;

    }

    @Override

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

    }

    private void initLanguages() {

        if (this.extensionOfLanguage == null) {

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

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

            for (ScriptEngineFactory factory : factories) {

                if( "ognl".equals(factory.getLanguageName()) ) {

                    continue;

                }

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

                if (extensions != null && !extensions.isEmpty()) {

                    extensionOfLanguage.put(

                            factory.getLanguageName().toLowerCase(),

                            extensions.get(0).toLowerCase()

                    );

                }

            }

            this.extensionOfLanguage = extensionOfLanguage;

        }

        if (this.languageOfExtension == null) {

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

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

            for (ScriptEngineFactory factory : factories) {

                if( "ognl".equals(factory.getLanguageName()) ) {

                    continue;

                }

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

                if (extensions != null) {

                    for (String extension1 : extensions) {

                        languageOfExtension.put(

                                extension1.toLowerCase(),

                                factory.getLanguageName().toLowerCase()

                        );

                    }

                }

            }

            this.languageOfExtension = languageOfExtension;

        }

    }

    @Override

    public String getExtensionOfLanguage(String langName) {

        if (langName == null) {

            return null;

        }

        langName = langName.toLowerCase();

        initLanguages();

        return this.extensionOfLanguage.get(langName);

    }

    @Override

    public List<String> getSupportedLanguages() {

        List<String> languages = new ArrayList<>();

        initLanguages();

        languages.addAll(this.extensionOfLanguage.keySet());

        Collections.sort(languages);

        return languages;

    }

    public String getLanguageOfExtension(String extension) {

        if (extension == null) {

            return null;

        }

        extension = extension.toLowerCase();

        if (extension.startsWith(".")) {

            extension = extension.substring(1);

        }

        initLanguages();

        return this.languageOfExtension.get(extension);

    }

    public Object get(String key) {

        return this.bindings.get(key);

    }

    public void put(String key, Object value) {

        this.bindings.put(key, value);

    }

    @Override

    public ScriptingHelpManager getHelpManager() {

        if (this.helpManager == null) {

            this.helpManager = new DefaultScriptingHelpManager(this);

        }

        return this.helpManager;

    }

    @Override

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

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

    }

    @Override

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

            return this.createExternalFile(folder, id);

        }

        return null;

    }

    @Override

    public List<String> getUnitTypes() {

        if (this.unitTypes == null) {

            this.unitTypes = new ArrayList<>();

            this.unitTypes.add(UNIT_SCRIPT);

            this.unitTypes.add(UNIT_DIALOG);

            this.unitTypes.add(UNIT_FOLDER);

            this.unitTypes.add(UNIT_EXTERNALFILE);

        }

        return this.unitTypes;

    }

    @Override

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

        }

    }

    @Override

    public List<File> getLibFolders() {

        return new ArrayList(this.libFolders);

    }

    @Override

    public Map<String, String> getLibFoldersVersions() {

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

        List<File> folders = this.getLibFolders();

        for (File folder : folders) {

            File parent = folder.getParentFile();

            File libVersions = new File(parent,folder.getName()+".versions");

            if( libVersions.exists() ) {

                this.loadLibVersions(versions, libVersions);

            }

        }

        if( versions.isEmpty() ) {

            return null;

        }

        return versions;

    }

    private void loadLibVersions(Map<String,String>versions, File file) {

        List<String> lines;

        try {

            lines = FileUtils.readLines(file);

        } catch (IOException ex) {

            LOG.warn("Can't load lib versions from '"+file+".",ex);

            return;

        }

        for (String line : lines) {

            String[] x = line.split("=");

            if( x.length==2 ) {

                versions.put(x[0], x[1]);

            } 

        }

    }

    @Override

    public ProviderFactory getInstallerFactory() {

        return new ScriptingInstallerProviderFactory();

    }

    public ProviderFactory getHelpInstallerFactory() {

        return new ScriptingHelpInstallerProviderFactory();

    }

    @Override

    public File getPackagesFolder() {

        return this.packagesFolder;

    }

    @Override

    public void setPackagesFolder(File folder) {

        this.packagesFolder = folder;

    }

}