Application: gvSIG desktop » gvSIG scripting

package org.gvsig.scripting.impl;

import groovy.lang.GroovyClassLoader;

import groovy.util.GroovyScriptEngine;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.io.PrintStream;

import java.io.Writer;

import java.net.URL;

import java.nio.charset.Charset;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashSet;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Set;

import javax.script.Compilable;

import javax.script.CompiledScript;

import javax.script.Invocable;

import javax.script.ScriptEngine;

import javax.script.ScriptException;

import org.apache.commons.io.Charsets;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.exception.ExceptionUtils;

import org.gvsig.scripting.CompileErrorException;

import org.gvsig.scripting.ExecuteErrorException;

import org.gvsig.scripting.Main;

import org.gvsig.scripting.ScriptingBaseScript;

import org.gvsig.scripting.ScriptingFolder;

import org.gvsig.scripting.ScriptingManager;

import org.gvsig.scripting.ScriptingScript;

import org.gvsig.scripting.ScriptingUnit;

import org.gvsig.tools.dispose.Disposable;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.observer.impl.DelegateWeakReferencingObservable;

import org.gvsig.tools.task.AbstractMonitorableTask;

import org.ini4j.Ini;

import org.python.core.Py;

import org.python.core.PyException;

import org.python.core.PyString;

import org.python.core.PySystemState;

import org.python.core.PyTraceback;

import org.python.core.imp;

import org.python.jsr223.MyPyScriptEngine;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings({"EqualsAndHashcode", "UseSpecificCatch"})

public class DefaultScriptingScript extends AbstractScript implements

        ScriptingScript {

    @SuppressWarnings("FieldNameHidesFieldInSuperclass")

    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultScriptingScript.class);

    protected String langName;

    protected String extension = null;

    protected String librarySuffix = null;

    protected ScriptEngine engine = null;

    protected CompiledScript compiledCode;

    protected boolean useSysPath;

    private String code = null;

    private String mainName = "main";

    private final DelegateWeakReferencingObservable delegatedObservable;

    private OutputWriter stdout;

    private OutputWriter stderr;

    public static class OutputWriter extends Writer {

        private final Set<Writer> writers = new HashSet<>();

        private final PrintStream out;

        private OutputWriter(PrintStream out) {

            this.out = out;

        }

        @Override

        public void write(char[] cbuf, int off, int len) throws IOException {

            try {

                byte[] buf = new String(cbuf).getBytes(Charset.forName("UTF-8"));

                out.write(buf, off, len);

            } catch (Exception ex) {

                LOGGER.warn("Can't output",ex);

            }

            for (Writer writer : writers) {

                try {

                    writer.write(cbuf, off, len);

                } catch (Exception ex) {

                    LOGGER.warn("Can't output",ex);

                }

            }

        }

        @Override

        public void flush() throws IOException {

            try {

                out.flush();

            } catch (Exception ex) {

                LOGGER.warn("Can't flush",ex);

            }

            for (Writer writer : writers) {

                try {

                    writer.flush();

                } catch (Exception ex) {

                    LOGGER.warn("Can't flush",ex);

                }

            }

        }

        @Override

        public void close() throws IOException {

        }

        private void addWriter(Writer out) {

            this.writers.add(out);

        }

        private void removeWriter(Writer out) {

            this.writers.remove(out);

        }

    }

    @SuppressWarnings("OverridableMethodCallInConstructor")

    protected DefaultScriptingScript(ScriptingFolder parent, String typename, ScriptingManager manager, String id) {

        super(parent, typename, manager, id);

        this.useSysPath = false;

        this.setLangName("python");

        this.setSaved(true);

        this.delegatedObservable = new DelegateWeakReferencingObservable(this);

        this.stdout = new OutputWriter(System.out);

        this.stderr = new OutputWriter(System.err);

    }

    public DefaultScriptingScript(ScriptingFolder parent, ScriptingManager manager, String id) {

        this(parent, ScriptingManager.UNIT_SCRIPT, manager, id);

    }

    public DefaultScriptingScript(ScriptingFolder parent, ScriptingManager manager, String id, String langName) {

        this(parent, ScriptingManager.UNIT_SCRIPT, manager, id);

        if( !StringUtils.isBlank(langName) ) {

            this.setLangName(langName);

        }

    }

    @Override

    public int hashCode() {

        File f = this.getFile();

        if( f!=null ) {

            return "#$FILE$#".hashCode() + f.getAbsolutePath().hashCode();

        }

        String s = this.getId();

        if( s != null ) {

            return "#$ID$#".hashCode() + s.hashCode();

        }

        s = this.getCode();

        if( s != null ) {

            return "#$CODE$#".hashCode() + s.hashCode();

        }

        return super.hashCode();

    }

    @Override

    public void addStdoutWriter(Writer out) {

        this.stdout.addWriter(out);

    }

    @Override

    public void addStderrWriter(Writer err) {

        this.stderr.addWriter(err);

    }

    @Override

    public void removeStdoutWriter(Writer out) {

        this.stdout.removeWriter(out);

    }

    @Override

    public void removeStderrWriter(Writer err) {

        this.stdout.removeWriter(err);

    }

    public Object __getattr__(String name) {

        try {

            ScriptEngine theEngine = this.getEngine();

            this.compile();

            return theEngine.get(name);

        } catch(Exception ex) {

            return null;

        }

    }

    public void __setattr__(String name, Object value) {

        ScriptEngine theEngine = this.getEngine();

        this.compile();

        theEngine.put(name, value);

    }

    public Object __call__() {

        return this.run();

    }

    public Object __call__(Object[] args) {

        return this.run(args);

    }

    public OutputWriter getStdout() {

        return this.stdout;

    }

    public OutputWriter getStderr() {

        return this.stderr;

    }

    protected void notifyErrors(Exception exception, String command) {

        this.delegatedObservable.notifyObservers(new BaseScriptingNotifycation(

                this, BaseScriptingNotifycation.RUNTIME_ERROR_NOTIFICATION,

                command, exception));

    }

    @Override

    public String getCode() {

        if (this.code == null) {

            File f = null;

            try {

                f = this.getFileResource(this.extension);

                Charset encoding = Charsets.toCharset(EncodingUtils.getEncoding(f));

                this.code = FileUtils.readFileToString(f, encoding);

            } catch (IOException e) {

                String fname = (f == null) ? "(null)" : f.getAbsolutePath();

                LOGGER.warn("Can't load code from file '" + fname + "'.");

            }

        }

        return this.code;

    }

    @Override

    public void setCode(String code) {

        this.code = code;

        this.engine = null;

        this.compiledCode = null;

        this.setSaved(false);

    }

    @Override

    public String getLibrarySuffix() {

        return this.librarySuffix;

    }

    @Override

    public void setLibrarySuffix(String librarySuffix) {

        this.librarySuffix = librarySuffix;

    }

    public List<File> getLibFolders() {

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

        String suffix = this.getLibrarySuffix();

        if( suffix == null ) {

            return folders;

        }

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

            File folder = folders.get(i);

            File f = new File(folder.getParentFile(),folder.getName()+suffix);

            if( f.exists() ) {

                folders.set(i, f);

            }

        }

        return folders;

    }

    protected String getCodeToInitializeEngine() {

        String initName = "org/gvsig/scripting/langs/"+this.getLangName().toLowerCase()+"/init.txt";

        try {

            InputStream template = this.getClass().getClassLoader().getResourceAsStream(initName);

            if( template == null ) {

                return null;

            }

            List<String> lines = IOUtils.readLines(template);

            return StringUtils.join(lines, "\n");

        } catch (Exception ex) {

            LOGGER.warn("Can't load code to initialize the script from '"+initName+".",ex);

            return null;

        }

    }

    private List<URL> getClassPath() {

        Set<URL> classPath = new HashSet<>();

        try {

//            ClassLoader myloader = this.getClass().getClassLoader();

//            if( myloader instanceof URLClassLoader) {

//                classPath.addAll(Arrays.asList(((URLClassLoader) myloader).getURLs()));

//            }

            URL url;

            if( StringUtils.isEmpty(this.getIsolationGroup()) ) {

                url = this.getFile().getParentFile().getCanonicalFile().toURI().toURL();

                classPath.add(url);

            }

            url = this.getManager().getUserFolder().getFile().getCanonicalFile().toURI().toURL();

            classPath.add(url);

            List<File> folders = getLibFolders();

            if( folders!=null ) {

                for (File folder : folders) {

                    url = folder.getAbsoluteFile().toURI().toURL();

                    classPath.add(url);

                }

            }

            ScriptingFolder folders2 = getManager().getSystemFolder();

            if( folders2!=null ) {

                for (ScriptingUnit folder : folders2.getUnits()) {

                    url = folder.getFile().getCanonicalFile().toURI().toURL();

                    classPath.add(url);

                }

            }

        } catch(Exception ex) {

        }

        return new ArrayList<>(classPath);

    }

    private void addClassPathToEngine(ScriptEngine engine, List<URL> classPath) {

        if( engine instanceof MyPyScriptEngine ) {

            PySystemState sys = Py.getSystemState();

            if( this.useSysPath ) {

//                logger.info("Running without sys.classLoader, "+ this.getFile().getAbsolutePath()+".");

//                ReentrantLock importLock =sys.getImportLock();

//                importLock.lock();

//                try {

                    Set<PyString> paths = new LinkedHashSet<>();

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

                        String path = (String) sys.path.get(i);

                        if( !(path.equals("__pyclasspath__/") || path.equals("__classpath__")) ) {

                            paths.add(Py.newString(path));

                        }

                    }

                    for (URL url : classPath) {

                        String path = FileUtils.toFile(url).getAbsolutePath();

                        paths.add(Py.newString(path));

                    }

                    paths.add(Py.newString("__classpath__"));

                    paths.add(Py.newString("__pyclasspath__/"));

                    sys.path.addAll(paths);

//                } finally {

//                    importLock.unlock();

//                }

            } else {

                ClassLoader loader = sys.getClassLoader();

                if( loader == null ) {

                    ClassLoader parentClassLoader = imp.getParentClassLoader();

                    loader = new MutableURLClassLoader(classPath, parentClassLoader);

                    sys.setClassLoader(loader);

                } else if( loader instanceof MutableURLClassLoader ) {

                    ((MutableURLClassLoader) loader).addUrls(classPath);

                }

            }

        } else if( engine instanceof GroovyScriptEngine ) {

            GroovyClassLoader loader = ((GroovyScriptEngine)engine).getGroovyClassLoader();

            Set<URL> urls = new HashSet();

            urls.addAll(Arrays.asList(loader.getURLs()));

            for (URL url : classPath) {

                if( ! urls.contains(url) ) {

                    loader.addURL(url);

                }

            }

        }

    }

    public ScriptEngine getEngine() {

        if (this.engine == null) {

            synchronized(this.getManager()) {

                ScriptEngine scriptEngine = this.manager.getEngineByLanguage(langName, this.getIsolationGroup());

                addClassPathToEngine(scriptEngine,getClassPath());

                scriptEngine.put("script", this);

                scriptEngine.put("Main", Main.class);

                scriptEngine.getContext().setWriter(stdout);

                scriptEngine.getContext().setErrorWriter(stderr);

                this.engine = scriptEngine;

                String theCode = this.getCodeToInitializeEngine();

                if (theCode != null) {

                    try {

                        this.engine.eval(theCode);

                    } catch (Exception ex) {

                        LOGGER.warn("Can't initialize engine with the code:\n" + theCode, ex);

                    }

                }

            }

        }

        return this.engine;

    }

    @Override

    protected void loadInf(Ini prefs) {

        super.loadInf(prefs);

        this.setMainName((String) getInfValue(prefs, "Script", "main", "main"));

        this.setLangName((String) getInfValue(prefs, "Script", "Lang",this.getLangName()));

        this.setLibrarySuffix((String) getInfValue(prefs, "Script", "LibraryVersion",null));

        this.useSysPath = getInfBoolean(prefs, "Script", "useSysPath", false);

    }

    @Override

    public void load(ScriptingFolder folder, String id) {

        this.setId(id);

        this.setParent(folder);

        String theExtension = FilenameUtils.getExtension(id);

        if( theExtension != null ) {

            String language = this.manager.getLanguageOfExtension(theExtension);

            if( language != null ) {

                this.setLangName(language);

            }

            this.setExtension(theExtension);

        }

        File f = getFileResource(".inf");

        if (f.isFile()) {

            Ini prefs = null;

            try {

                prefs = new Ini(f);

            } catch (Exception e) {

                LOGGER.warn("Can't load 'inf' file '" + f.getAbsolutePath() + "'.", e);

            }

            loadInf(prefs);

        }

        this.setCode(null);

        this.setSaved(true);

    }

    @Override

    public void save() {

        this.saveInfo();

        // Guardo el codigo en el fichero

        File fcode = this.getFileResource(this.getExtension());

        try {

            String text = this.getCode();

            Charset encoding = Charsets.toCharset(EncodingUtils.getEncoding(text));

            FileUtils.write(fcode, text, encoding);

        } catch (Exception e) {

            LOGGER.warn("Can't write code to file '" + fcode.getAbsolutePath() + "'.", e);

        }

        this.setSaved(true);

    }

    private void saveInfo() {

        File f = getFileResource(".inf");

        if (!f.isFile()) {

            try {

                f.createNewFile();

            } catch (Exception e) {

                LOGGER.warn("Can't create 'inf' file '" + f.getAbsolutePath() + "'.", e);

            }

        }

        Ini prefs = null;

        try {

            prefs = new Ini(f);

        } catch (Exception e) {

            LOGGER.warn("Can't load 'inf' file '" + f.getAbsolutePath() + "'.", e);

        }

        save(prefs);

    }

    @Override

    protected void save(Ini prefs) {

        super.save(prefs);

        prefs.put("Script", "main", this.getMainName());

        prefs.put("Script", "Lang", this.getLangName());

        if( this.useSysPath ) {

            prefs.put("Script", "useSysPath", this.useSysPath);

        }

        try {

            prefs.store();

        } catch (IOException e) {

            String fname = (prefs.getFile() == null) ? "(null)" : prefs.getFile().getAbsolutePath();

            LOGGER.warn("Can't save inf file (" + fname + ").", e);

        }

    }

    @Override

    public String getLangName() {

        return this.langName;

    }

    protected void setLangName(final String langName) {

        if( langName == null ) {

            return;

        }

        this.langName = langName;

        this.setExtension(this.manager.getExtensionOfLanguage(this.langName));

    }

    @Override

    public String[] getIconNames() {

        return new String[]{

            "scripting-icon-" + this.getLangName().toLowerCase(),

            "scripting-icon-" + this.getLangName().toLowerCase() + "-open"

        };

    }

    @Override

    public String getMainName() {

        return this.mainName;

    }

    @Override

    public void setMainName(final String mainName) {

        this.mainName = mainName;

    }

    @Override

    public List<File> getFiles() {

        List<File> l = new ArrayList<>();

        l.add(this.getScriptFile());

        return l;

    }

    public String getExtension() {

        return this.extension;

    }

    public void setExtension(final String extension) {

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

            this.extension = "." + extension;

        } else {

            this.extension = extension;

        }

    }

    @Override

    public void addObserver(final Observer o) {

        this.delegatedObservable.addObserver(o);

    }

    @Override

    public void deleteObserver(final Observer o) {

        this.delegatedObservable.deleteObserver(o);

    }

    @Override

    public void deleteObservers() {

        this.delegatedObservable.deleteObservers();

    }

    @Override

    public void put(final String name, final Object value) {

        this.getEngine().put(name, value);

    }

    @Override

    public void compile() {

        if (this.compiledCode == null) {

            ScriptEngine theEngine = this.getEngine();

            if (theEngine instanceof Compilable) {

                try {

                    Compilable compilable = (Compilable) theEngine;

                    String theCode = this.getCode();

                    if( "python".equalsIgnoreCase(this.getLangName()) ) {

                        // If a Unicode string with a coding declaration is passed to compile(),

                        // a SyntaxError will be raised, but this is necessary to import from

                        // another module, so we remove it.

                        // http://bugs.jython.org/issue1696

                        theCode = theCode.replaceFirst("^\\s*#([^:\\n]*)coding:","#$1 c-o-d-i-n-g:");

                    }

                    this.compiledCode = compilable.compile(theCode);

                    if( theEngine instanceof Invocable) {

                        this.compiledCode.eval();

                    }

                } catch (ScriptException e) {

                    Object[] location = this.getLocation(e);

                    CompileErrorException ce = new CompileErrorException(

                            e.getMessage(),

                            (File) location[0],

                            (int) location[1],

                            (int) location[2],

                            e

                    );

                    notifyErrors(ce, "compile");

                    throw ce;

                } catch (Throwable e) {

                    CompileErrorException ce = new CompileErrorException(e.getMessage(), this.getScriptFile(), e);

                    notifyErrors(new Exception(e), "compile");

                    throw ce;

                }

            } else {

                String theCode = this.getCode();

                try {

                    theEngine.eval(theCode);

                } catch (ScriptException e) {

                    Object[] location = this.getLocation(e);

                    CompileErrorException ce = new CompileErrorException(

                            e.getMessage(),

                            (File) location[0],

                            (int) location[1],

                            (int) location[2],

                            e

                    );

                    notifyErrors(ce, "compile");

                    throw ce;

                }

            }

        }

    }

    public void addDisposable(Disposable disposable) {

        //pass

    }

    /**

     * Run the main function of this script.

     * This method is created by familiarity when running the script from another script.

     * @return

     */

    public Object main() {

        return this.run(null);

    }

    /**

     * Run the main function of this script.

     * This method is created by familiarity when running the script from another script.

     * @param args

     * @return

     */

    public Object main(Object... args) {

        return this.run(args);

    }

    @Override

    public Object run() {

        return this.run(null);

    }

    @Override

    public Object run(Object args[]) {

        if( !this.isEnabled() ) {

            System.err.printf("The script '"+this.getName()+"' is not enabled, see properties page to change.\n");

            return null;

        }

        if (args == null) {

            args = new Object[]{};

        }

        this.compile();

        return this.invokeFunction(this.getMainName(), args);

    }

    @Override

    public Object invokeFunction(final String name, Object args[]) {

        try {

            if (this.getEngine() instanceof Invocable) {

                Invocable invocable = (Invocable) this.getEngine();

                this.compile();

                if (args == null) {

                    args = new Object[]{};

                }

                return invocable.invokeFunction(name, args);

            } else {

                if (this.compiledCode != null) {

                    Object x = this.compiledCode.eval();

                    if( x instanceof Main ) {

                        return ((Main) x).main(args);

                    } else if(x instanceof Runnable) {

                        ((Runnable) x).run();

                    }

                }

                return null;

            }

        } catch (ScriptException e) {

            Object[] location = this.getLocation(e);

            ExecuteErrorException ee = new ExecuteErrorException(

                    e.getMessage(),

                    (File) location[0],

                    (int) location[1],

                    (int) location[2],

                    e

            );

            notifyErrors(ee, "invoke");

            throw ee;

        } catch (Error | Exception e) {

            ExecuteErrorException ee = new ExecuteErrorException(e.getMessage(), this.getScriptFile(), e);

            notifyErrors(ee, "invoke");

            throw ee;

        }

    }

    @Override

    public File getScriptFile() {

        return this.getFileResource(extension);

    }

    private Object[] getLocation(ScriptException e) {

        Throwable[] es = ExceptionUtils.getThrowables(e);

        Exception dbgex; // Para debug con mas comodidad

        for( Throwable t : es) {

            if( t instanceof PyException ) {

                try {

                    PyException pyex = (PyException)t;

                    PyTraceback tb = pyex.traceback;

                    if( tb!=null ) {

                        while( tb.tb_next!=null ) {

                            tb = (PyTraceback) tb.tb_next;

                        }

                        String s = tb.tb_frame.f_globals.__getitem__(new PyString("__file__")).asString();

                        if( s.endsWith("$py.class") ) {

                            s = s.substring(0, s.length()-9) + ".py";

                            File resource = new File(s);

                            return new Object[] { resource, tb.tb_lineno, 0};

                        }

                        return new Object[] { this.getScriptFile(), tb.tb_lineno, 0};

                    }

                } catch(Exception ex) {

                    // Pass

                    dbgex = ex;

                }

            }

        }

        int column = e.getColumnNumber();

        if( column < 0 ) {

            column = 0;

        }

        return new Object[] { this.getScriptFile(), e.getLineNumber(), column };

    }

    @Override

    public Object invokeMethod(final Object obj, final String name, Object[] args)

            throws NoSuchMethodException {

        if (this.getEngine() instanceof Invocable) {

            Invocable invocable = (Invocable) this.getEngine();

            this.compile();

            if (args == null) {

                args = new Object[]{};

            }

            try {

                return invocable.invokeMethod(obj, name, args);

            } catch (ScriptException e) {

                ExecuteErrorException ee = new ExecuteErrorException(e.getMessage(), this.getScriptFile(), e.getLineNumber(), e.getColumnNumber(), e);

                notifyErrors(ee, "invoke");

                throw ee;

            } catch (Throwable e) {

                ExecuteErrorException ee = new ExecuteErrorException(e.getMessage(), this.getScriptFile(), e);

                notifyErrors(ee, "invoke");

                throw ee;

            }

        } else {

            return null;

        }

    }

    @Override

    public File getResource(String filename) {

        return new File(this.getParent().getFile(), filename);

    }

    @Override

    public String getMimeType() {

        return "text/"+ this.getLangName();

    }

    @Override

    protected void console_println(String s) {

        super.console_println(s);

        try {

            this.stdout.write(s+"\n");

        } catch (IOException ex) {

        }

    }

    class ScriptTask extends AbstractMonitorableTask {

        ScriptingBaseScript script = null;

        Object[] args = null;

        protected ScriptTask(ScriptingBaseScript script, Object[] args) {

            super(script.getName(), false);

            this.args = args;

            this.script = script;

            this.script.put("task", this);

            this.script.put("taskStatus", this.getTaskStatus());

        }

        @Override

        public void run() {

            try {

                console_println("Running script " + this.script.getName() + ".");

                script.run(this.args);

                console_println("Script " + this.script.getName() + " terminated.");

            } catch (Throwable e) {

                console_println("Stript " + this.script.getName() + " aborted.");

            } finally {

                this.taskStatus.terminate();

                try {

                    Thread.sleep(3000);

                } catch (InterruptedException e) {

                    // Ignore

                }

                this.taskStatus.remove();

            }

        }

        public void showTaskStatus() {

            this.taskStatus.add();

        }

    }

    @Override

    public void runAsTask(Object[] args) {

        if( !this.isEnabled() ) {

            System.err.printf("The script '"+this.getName()+"' is not enabled, see properties page to change.\n");

            return;

        }

        ScriptTask task = new ScriptTask(this, args);

        task.start();

    }

    @Override

    public boolean remove() {

        boolean r = true;

        File folder = this.getParent().getFile();

        File f = new File(folder, this.getId() + ".inf");

        try {

            FileUtils.forceDelete(f);

        } catch (IOException e) {

            LOGGER.warn("Can't remove inf file '" + f.getAbsolutePath() + "'.", e);

            r = false;

        }

        try {

            f = new File(folder, this.getId() + this.getExtension());

            FileUtils.forceDelete(f);

        } catch (IOException e) {

            LOGGER.warn("Can't remove code file '" + f.getAbsolutePath() + "'.", e);

            r = false;

        }

        return r;

    }

    @Override

    public void create(ScriptingFolder folder, String id, String language) {

        this.setParent(folder);

        this.setId(id);

        if (language == null) {

            this.setLangName("python");

        } else {

            this.setLangName(language);

        }

        this.setExtension(this.manager.getExtensionOfLanguage(getLangName()));

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

        try {

            file.createNewFile();

        } catch (IOException e) {

            LOGGER.warn("Can't create file of the dialog in '" + file.getAbsolutePath() + "'.", e);

        }

        File fcode = this.getFileResource(this.getExtension());

        if( fcode.exists() ) {

            this.saveInfo();

        } else {

            String template = this.getNewTemplate();

            if( template != null ) {

                this.setCode(template);

            }

            this.save();

        }

    }

    public String getNewTemplate() {

        String theTemplateName = "org/gvsig/scripting/langs/"+this.getLangName().toLowerCase()+"/new_template.txt";

        try {

            InputStream template = this.getClass().getClassLoader().getResourceAsStream(theTemplateName);

            if( template == null ) {

                return null;

            }

            List<String> lines = IOUtils.readLines(template);

            return StringUtils.join(lines, "\n");