Application: gvSIG desktop » gvSIG scripting

package org.gvsig.scripting.impl;

import java.io.File;

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.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.service.spi.ProviderFactory;

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;

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

    }

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

    }

    protected ScriptEngine getEngine(String langName) {

        ScriptEngineManager manager = this.getEngineManager();

        ScriptEngine engine = manager.getEngineByName(langName);

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

        return engine;

    }

    public ImageIcon getIcon(String name) {

        return this.icons.get(name);

    }

    @Override

    public String getEngineNameByLanguage(String langName) {

        List<ScriptEngineFactory> factories

                = getEngineManager().getEngineFactories();

        for (ScriptEngineFactory factory : factories) {

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

                return factory.getEngineName();

            }

        }

        return null;

    }

    public ScriptEngine getEngineByLanguage(String langName) {

        List<ScriptEngineFactory> factories

                = getEngineManager().getEngineFactories();

        for (ScriptEngineFactory factory : factories) {

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

                return factory.getScriptEngine();

            }

        }

        return null;

    }

    @Override

    public boolean validateUnitId(ScriptingFolder folder, String id) {

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

        String fileName;

        String s[];

        String extension;

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

    }

    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;

    }

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

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

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

        }

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

        }

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

        }

    }

    public List<File> getLibFolders() {

        return this.libFolders;

    }

    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;

    }

}