Application: gvSIG desktop » gvSIG scripting

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

	<modelVersion>4.0.0</modelVersion>

	<artifactId>org.gvsig.scripting.lib</artifactId>

	<packaging>pom</packaging>

	<name>${project.artifactId}</name>

	<parent>

		<groupId>org.gvsig</groupId>

		<artifactId>org.gvsig.scripting</artifactId>

		<version>2.3.241</version>

	</parent>

	<modules>

		<module>org.gvsig.scripting.lib.api</module>

		<module>org.gvsig.scripting.lib.impl</module>

	</modules>

</project>

<?xml version="1.0" encoding="UTF-8"?>

<actions>

        <action>

            <actionName>CUSTOM-dependency:tree</actionName>

            <displayName>dependency:tree</displayName>

            <recursive>false</recursive>

            <goals>

                <goal>dependency:tree</goal>

            </goals>

        </action>

    </actions>

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<!-- 

Log4J configuration file for unit tests execution.

 -->

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

	<!-- Appender configuration to show logging messages through the console -->

	<appender name="CONSOLE" class="org.apache.log4j.ConsoleAppender">

		<layout class="org.apache.log4j.PatternLayout">

			<param name="ConversionPattern" value="%d{HH:mm:ss,SSS} %-5p [%c{2}.%M()]\n  %m%n" />

		</layout>

	</appender>

	<!-- 

	Activate logging messages of DEBUG level of higher only for the

	DefaultExampleManager class.

	You can put full classes names or packages instead, to configure

	logging for all the classes and subpackages of the package.

	-->

	<category name="org.gvsig.scripting.impl.DefaultExampleManager">

		<priority value="DEBUG" />

	</category>

	<!-- 

	By default, show only logging messages of INFO level or higher, 

	through the previously configured CONSOLE appender. 

	-->

	<root>

		<priority value="INFO" />

		<appender-ref ref="CONSOLE" />

	</root>

</log4j:configuration>

def main():

  print 'hola'

def hola(name):

  return 'hola %s' % name

def adios():

  print 'adios'

<?xml version="1.0" encoding="ISO-8859-1"?>

<!-- generated by ThinG, the Thinlet GUI editor -->

<panel>

    <button text="hola" action="click"/>

</panel>

def click():

  print 'click'

def main():

  print 'hola'

def hola(name):

  return 'hola %s' % name

def adios():

  print 'adios'

#set( $symbol_pound = '#' )

#set( $symbol_dollar = '$' )

#set( $symbol_escape = '\' )

Put into this folder the resources needed by your test classes.

This folder is added to the Tests classpath, so you can load any resources 

through the ClassLoader.

By default, in this folder you can find an example of log4j configuration,

prepared to log messages through the console, so logging works when you

run your tests classes.

#set( $symbol_pound = '#' )

#set( $symbol_dollar = '$' )

#set( $symbol_escape = '\' )

For each class you are going to test, create one Test class with the same

name as the class to test, ending with Test.

For example, the unit tests of the "ExampleLibrary" class are performed

by the "ExampleLibraryTest" class.

package org.gvsig.scripting;

public interface Main {

    public Object main(Object args[]);

}

package org.gvsig.scripting.impl;

import org.apache.commons.lang3.BooleanUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.scripting.ScriptingBaseScript;

import org.gvsig.scripting.ScriptingFolder;

import org.gvsig.scripting.ScriptingManager;

import org.ini4j.Ini;

public abstract class AbstractScript extends AbstractUnit implements ScriptingBaseScript{

        protected boolean enabled;

        protected String isolationGroup;

        public AbstractScript(ScriptingFolder parent, String typename, ScriptingManager manager, String id) {

           super(parent, typename, manager, id);

           this.enabled = true;

           this.isolationGroup = null;

        }

        @Override

        public boolean isEnabled() {

            return this.enabled;

        }

        @Override

        public void setEnabled(boolean enabled) {

            firePropertyChangeListener("enabled", enabled, this.enabled);

            this.enabled = enabled;

        }

        @Override

        public String getIsolationGroup() {

            return this.isolationGroup;

        }

        @Override

        public void setIsolationGroup(String group) {

            firePropertyChangeListener("isolationGroup", group, this.isolationGroup);

            this.isolationGroup = group;

        }

        @Override

	protected void save(Ini prefs){

                prefs.put("Script", "enable", BooleanUtils.toStringTrueFalse(this.enabled));

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

		super.save(prefs);

	}

        @Override

	protected void loadInf(Ini prefs){

		super.loadInf(prefs);

                this.enabled = this.getInfBoolean(prefs,"Script","enable", true);

                this.isolationGroup = this.getInfString(prefs,"Script","isolationGroup", null);

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

                    this.isolationGroup = null;

                }

        }

        public void registerDataFolder(String id) {

            this.getManager().registerDataFolder(this.getParent(), id);

        }

}

package org.gvsig.scripting.impl;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.net.URL;

import java.net.URLClassLoader;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Enumeration;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class MutableURLClassLoader extends URLClassLoader {

    protected static final Logger LOGGER = LoggerFactory.getLogger(MutableURLClassLoader.class);

    public MutableURLClassLoader(List<URL> urls, ClassLoader parent) {

        super(urls.toArray(new URL[urls.size()]),parent);

    }

    public void addUrls(List<URL> urls) {

        List<URL> currentsURLs = new ArrayList<>();

        currentsURLs.addAll(Arrays.asList(this.getURLs()));

        for (URL url : urls) {

            if( ! currentsURLs.contains(url) ) {

                this.addURL(url);

                currentsURLs.add(url);

            }

        }

    }

    public boolean needRecompile(String name, URL url) {

        if( url!=null && name.endsWith("$py.class") ) {

            if( StringUtils.equalsIgnoreCase(url.getProtocol(),"file") ) {

                String path = url.getPath();

                File binary = new File(path);

                File source = new File(StringUtils.left(path, path.length()-9)+".py");

                if( !binary.exists() || org.apache.commons.io.FileUtils.isFileNewer(source, binary) ) {

                    return true;

                }

            }

        }

        return false;

    }

    @Override

    public URL getResource(String name) {

        // Para acceder a esto desde python

        // import sys

        // print sys.getClassLoader().getResource("pylint/utils$py.class")

        URL x = super.getResource(name); 

        if( needRecompile(name, x) ) {

            LOGGER.trace("getResoure("+name+") -> null (need recompile).");

            return null;

        }

        LOGGER.trace("getResoure("+name+") -> "+x);

        return x;

    }

    @Override

    public InputStream getResourceAsStream(String name) {

        URL url = super.getResource(name); 

        if( needRecompile(name, url) ) {

            LOGGER.trace("getResourceAsStream("+name+") -> null (need recompile).");

            return null;

        }

        InputStream x = super.getResourceAsStream(name); 

        LOGGER.trace("getResourceAsStream("+name+") -> "+(x==null? "null":"(stream)"));

        return x;

    }

    @Override

    public Enumeration<URL> getResources(String name) throws IOException {

        Enumeration<URL> urls = super.getResources(name); 

        LOGGER.info("getResources("+name+") -> "+(urls==null? "null":urls));

        return urls;

    }

    public String getResourcePath(String name) {

        if( name.startsWith("__pyclasspath__/") ) {

            name = name.substring(16);

        }

        URL url = this.getResource(name);

        if( url == null ) {

            return name;

        }

        File f = org.apache.commons.io.FileUtils.toFile(url);

        return f.getAbsolutePath();

    }    

    public List<String> path(List<String>basepath) {

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

      if( basepath!=null ) {

        for (String folder : basepath) {

          if( folder==null || folder.startsWith("__") || path.contains(folder) ) {

            continue;

          }

          path.add(folder);

        }

      }

      URL[] urls = this.getURLs();

      for (URL url : urls) {

        if( url==null || !StringUtils.equalsIgnoreCase(url.getProtocol(),"file") ) {

          continue;

        }

        String folder = url.getPath();

        if( folder==null || folder.isEmpty() || path.contains(folder) ) {

          continue;

        }

        path.add(folder);

      }

      return path;

    }

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 * 

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 

 * MA  02110-1301, USA.

 * 

 */

package org.gvsig.scripting.impl;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.util.Iterator;

import org.apache.commons.io.FileUtils;

import org.gvsig.installer.lib.api.PackageInfo;

import org.gvsig.installer.lib.api.execution.InstallPackageServiceException;

import org.gvsig.installer.lib.spi.InstallPackageProviderServices;

import org.gvsig.installer.lib.spi.InstallerProviderLocator;

import org.gvsig.installer.lib.spi.InstallerProviderManager;

import org.gvsig.installer.lib.spi.execution.InstallPackageProvider;

import org.gvsig.scripting.ScriptingLocator;

import org.gvsig.scripting.ScriptingManager;

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

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

public class ScriptingInstallerProvider extends AbstractProvider

    implements InstallPackageProvider {

    public ScriptingInstallerProvider(ProviderServices providerServices) {

        super(providerServices);

    }

    public void install(File applicationDirectory, InputStream inputStream,

        PackageInfo packageInfo) throws InstallPackageServiceException {

    	ScriptingManager scriptingManager = ScriptingLocator.getManager();

    	File target = scriptingManager.getRootUserFolder();

        target = new File(target,"addons");

        try {

            if( ! target.exists() ) {

                FileUtils.forceMkdir(target);

            }

            InstallerProviderManager installerProviderManager =

                InstallerProviderLocator.getProviderManager();

            InstallPackageProviderServices installerProviderServices =

                installerProviderManager.createInstallerProviderServices();

            installerProviderServices.decompress(inputStream, target);

            // Ajustamos las fechas de modificacion de los ficheros de forma que

            // los fuentes sean mas nuevos que los binarios.

            // Esto forzara que se recompilen la primera vez que se ejecuten.

            // Si no hacemos esto y las fecha de los binarios son futuras, aunque

            // se editen y cambien los fuentes nunca se reccompilaran.

            Iterator<File> it = FileUtils.iterateFiles(target, new String[] {"class"}, true);

            while( it.hasNext() ) {

                File f = it.next();

                try {

                    FileUtils.touch(f);

                } catch (IOException e) {

                    // Do nothing

                }

            }

            it = FileUtils.iterateFiles(target, new String[] {"py","r","scala","groovy"}, true);

            while( it.hasNext() ) {

                File f = it.next();

                try {

                    FileUtils.touch(f);

                } catch (IOException e) {

                    // Do nothing

                }

            }

        } catch (Exception e) {

            throw new InstallPackageServiceException(e);

        }

    }

    public void installLater(File applicationDirectory,

        InputStream inputStream, PackageInfo packageInfo)

        throws InstallPackageServiceException, IOException {

        // TODO Auto-generated method stub

    }

}

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

        } catch (Exception ex) {

            LOGGER.warn("Can't load new-template from '"+theTemplateName+"'.",ex);

            return null;

        }

    }

    public ScriptingUnit get(String name) {

        return this.manager.getScript(name);

    }

    public ScriptingUnit get(File file) {

        return this.manager.getScript(file);

    }

    @Override

    public boolean move(ScriptingFolder target) {

        if (! manager.validateUnitId(target, this.getId()) ) {

            LOGGER.info("Can't move script '"+this.getId()+"' to '"+target.getFile().getAbsolutePath()+"', is not valid.");

            return false;

        }

        if( !this.isSaved() ) {

            LOGGER.info("Can't move script '"+this.getId()+"', is not saved.");

            return false;

        }

        try {

            File codefile = this.getFileResource(this.extension);

            FileUtils.moveFileToDirectory(this.getFile(), target.getFile(),true);

            FileUtils.moveFileToDirectory(codefile, target.getFile(), true);

            this.parent = target;

            this.load(target, id);

        } catch (IOException ex) {

            LOGGER.info("Can't move script '"+this.getId()+"' to '"+target.getFile().getAbsolutePath()+"', "+ex.getMessage(),ex);

            return false;

        }

        return true;

    }

    @Override

    public boolean rename(String newId) {

        if (! manager.validateUnitId(this.getParent(), newId) ) {

            LOGGER.info("Can't rename script '"+this.getId()+"', target id '"+newId+"' is not valid.");

            return false;

        }

        if( !this.isSaved() ) {

            LOGGER.info("Can't rename script '"+this.getId()+"', is not saved.");

            return false;

        }

        try {

            ScriptingFolder target = this.getParent();

            File codefile = this.getFileResource(this.extension);

            FileUtils.moveFile(this.getFile(),  new File(target.getFile(),newId+".inf") );

            FileUtils.moveFile(codefile, new File(target.getFile(),newId+this.extension));

            this.setId(newId);

            this.saveInfo();

            this.load(target, id);

        } catch (IOException ex) {

            LOGGER.info("Can't rename script '"+this.getId()+"' to '"+newId+"', "+ex.getMessage(),ex);

            return false;

        }        

        return true;

    }

    @Override

    public List<String> getNames() {

        ScriptEngine theEngine = this.getEngine();

        if( theEngine instanceof MyPyScriptEngine ) {

            return ((MyPyScriptEngine) theEngine).getLocalNames();

        }

        return null;

    }    

    @Override

    public String getText() {

        return this.getCode();

    }

    @Override

    public void setText(String text) {

        this.setCode(text);

    }

}

package org.gvsig.scripting.impl;

import java.io.File;

import java.io.FileFilter;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Properties;

import java.util.Set;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.BooleanUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.scripting.DataFolderFound;

import org.gvsig.tools.packageutils.Version;

import org.gvsig.scripting.ScriptingFolder;

import org.gvsig.scripting.ScriptingManager;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.packageutils.PackageManager;

import org.gvsig.tools.util.FolderSet;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class DataFolderManager {

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

    private static final String DATAFOLDER_FILENAME = "data";

    private class DataFolderRegisterEntry {

        public String folderId;

        public String folderPath;

        public boolean processed;

    }

    private class DataFolderRegister implements Iterable<DataFolderRegisterEntry> {

        private static final String DATAFOLDER_REGISTER_FILENAME = "data.properties";

        private static final String ID_KEY_SUFFIX = ".id";

        private static final String PATH_KEY_SUFFIX = ".path";

        private static final String PROCESSED_KEY_SUFFIX = ".processed";

        private Properties props;