Application: gvSIG desktop » gvSIG scripting

package org.gvsig.scripting.impl;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import java.util.List;

import java.util.Map;

import javax.script.Compilable;

import javax.script.CompiledScript;

import javax.script.Invocable;

import javax.script.ScriptEngine;

import javax.script.ScriptException;

import org.gvsig.scripting.CompileErrorException;

import org.gvsig.scripting.ExecuteErrorException;

import org.gvsig.scripting.ScriptingFolder;

import org.gvsig.scripting.ScriptingManager;

import org.gvsig.scripting.ScriptingScript;

import org.gvsig.tools.dispose.Disposable;

import org.gvsig.tools.observer.Observer;

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

import org.ini4j.Ini;

import org.ini4j.InvalidFileFormatException;

@SuppressWarnings("restriction")

public class DefaultScriptingScript extends AbstractScript implements

                ScriptingScript {

        protected String langName;

        protected String extension = null;

        protected ScriptEngine engine = null;

        protected CompiledScript compiledCode;

        private String code = null;

        private String mainName = "main";

        private boolean saved;

        private final DelegateWeakReferencingObservable delegatedObservable;

        public DefaultScriptingScript(ScriptingManager manager) {

                super(manager);

                this.setLangName("python");

                this.setSaved(true);

                this.delegatedObservable = new DelegateWeakReferencingObservable(this);

        }

        protected void notifyErrors(Exception exception, String command) {

                this.delegatedObservable.notifyObservers(new BaseScriptingNotifycation(

                                this, BaseScriptingNotifycation.RUNTIME_ERROR_NOTIFICATION,

                                command, exception));

        }

//        protected void launchCompilingException(Exception exception, String command) {

//                this.delegatedObservable.notifyObservers(new BaseScriptingNotifycation(

//                                this, BaseScriptingNotifycation.COMPILE_ERROR_NOTIFICATION,

//                                command, exception));

//        }

        public void setSaved(boolean saved) {

                this.saved = saved;

        }

        public String getCode() {

                if (this.code != null) {

                        return this.code;

                }

                return DefaultScriptingManager.getStringFromFile(this.getFileResource(

                                this.extension).getAbsolutePath());

        }

        public void setCode(String code) {

                this.code = code;

                this.engine = null;

                this.compiledCode = null;

                this.setSaved(false);

        }

        private String getPreparedCode() {

                String code = null;

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

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

                        if (libFolders != null && libFolders.size() > 0) {

                                StringBuffer buffer = new StringBuffer();

                                buffer.append("import sys;");

                                for (File file : libFolders) {

                                        buffer.append("sys.path.append('");

                                        buffer.append(file.getAbsolutePath());

                                        buffer.append("');");

                                }

                                code = buffer.toString();

                        }

                }

                if (code == null) {

                        code = this.getCode();

                } else {

                        code = code + this.getCode();

                }

                return code;

        }

        protected ScriptEngine getEngine() {

                if (this.engine == null) {

                        ScriptEngine scriptEngine = this.manager.getEngine(this

                                        .getLangName());

                        scriptEngine.put("script", this);

                        this.engine = scriptEngine;

                }

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

        }

        @Override

        public void load(ScriptingFolder folder, String id) {

                this.setId(id);

                this.setParent(folder);

                Map<String, String> languages = this.manager

                                .getSupportedLanguagesByExtension();

                String s[] = id.split("\\.");

                if (s.length >= 2) {

                        String extension = "." + s[s.length - 1];

                        String langName = languages.get(extension);

                        this.setLangName(langName);

                        this.setExtension(extension);

                }

                File f = getFileResource(".inf");

                if (f.isFile()) {

                        Ini prefs = null;

                        try {

                                prefs = new Ini(f);

                        } catch (InvalidFileFormatException e) {

                                e.printStackTrace();

                        } catch (IOException e) {

                                e.printStackTrace();

                        }

                        loadInf(prefs);

                }

                this.setSaved(true);

        }

        public void save() {

                File f = getFileResource(".inf");

                if (!f.isFile()) {

                        try {

                                f.createNewFile();

                        } catch (IOException e) {

                                e.printStackTrace();

                        }

                }

                Ini prefs = null;

                try {

                        prefs = new Ini(f);

                } catch (InvalidFileFormatException e) {

                        e.printStackTrace();

                } catch (IOException e) {

                        e.printStackTrace();

                }

                save(prefs);

                // Guardo el codigo en el fichero

                try {

                        FileWriter fstream = new FileWriter(

                                        ((DefaultScriptingFolder) this.getParent()).getPath()

                                                        + File.separator + this.getId()

                                                        + this.getExtension());

                        BufferedWriter out = new BufferedWriter(fstream);

                        out.write(this.getCode());

                        out.close();

                } catch (Exception e) {

                        System.err.println("Error: " + e.getMessage());

                }

                this.setSaved(true);

        }

        protected void save(Ini prefs) {

                super.save(prefs);

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

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

                try {

                        prefs.store();

                } catch (IOException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

        }

        public String getLangName() {

                return this.langName;

        }

        protected void setLangName(final String langName) {

                this.langName = langName;

                this.extension = this.manager.getExtensionByLanguage(this.langName);

        }

        public String[] getIconNames() {

                return new String[] { "scripting_" + this.getLangName().toLowerCase(),

                                null };

        }

        public String getMainName() {

                return this.mainName;

        }

        public void setMainName(final String mainName) {

                this.mainName = mainName;

        }

        public String getExtension() {

                return this.extension;

        }

        public void setExtension(final String extension) {

                this.extension = extension;

        }

        public boolean isSaved() {

                return this.saved;

        }

        public void addObserver(final Observer o) {

                this.delegatedObservable.addObserver(o);

        }

        public void deleteObserver(final Observer o) {

                this.delegatedObservable.deleteObserver(o);

        }

        public void deleteObservers() {

                this.delegatedObservable.deleteObservers();

        }

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

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

        }

        public void compile() {

                if (this.compiledCode == null) {

                        ScriptEngine engine = this.getEngine();

                        if (engine instanceof Compilable) {

                                try {

                                        Compilable compilable = (Compilable) engine;

                                        this.compiledCode = compilable.compile(this.getPreparedCode());

                                        this.compiledCode.eval();

                                } catch (ScriptException e) {

                                        CompileErrorException ce = new CompileErrorException(e.getMessage(), this.getName(), e.getLineNumber(), e.getColumnNumber(), e);

                                        notifyErrors(ce, "compile");

                                        throw ce;

                                } catch (Throwable e) {

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

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

                                        throw ce;

                                }

                        }

                }

        }

        public Object run() {

                return this.run(null);

        }

        public void addDisposable(Disposable disposable){

                //pass

        }

        public Object run(Object args[]) {

                if (args == null) {

                        args = new Object[] {};

                }

                this.compile();

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

        }

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

                if (this.getEngine() instanceof Invocable) {

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

                        this.compile();

                        if( args == null ) {

                                args = new Object[] {};

                        }

                        try {

                                return invocable.invokeFunction(name, args);

                        } catch (ScriptException e) {

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

                                notifyErrors(ee, "invoke");

                                throw ee;

                        } catch (Throwable e) {

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

                                notifyErrors(ee, "invoke");

                                throw ee;

                        }

                } else {

                        return null;

                }

        }

        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.getName(), e.getLineNumber(), e.getColumnNumber(), e);

                                notifyErrors(ee, "invoke");

                                throw ee;

                        } catch (Throwable e) {

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

                                notifyErrors(ee, "invoke");

                                throw ee;

                        }

                } else {

                        return null;

                }

        }

        public File getResource(String filename) {

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

        }

}