Application: gvSIG desktop » gvSIG scripting

package org.gvsig.scripting.impl;

import groovy.lang.MissingMethodException;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import java.util.Map;

import javax.script.Invocable;

import javax.script.ScriptEngine;

import javax.script.ScriptException;

import org.codehaus.groovy.control.MultipleCompilationErrorsException;

import org.ini4j.Ini;

import org.ini4j.InvalidFileFormatException;

import org.python.core.PySyntaxError;

import org.gvsig.scripting.ScriptingFolder;

import org.gvsig.scripting.ScriptingManager;

import org.gvsig.scripting.ScriptingScript;

import org.gvsig.tools.observer.Observer;

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

public class DefaultScriptingScript extends AbstractScript implements ScriptingScript{

        protected String langName;

        protected String extension = null;

        protected Invocable engine = null;

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

        }

        private void launchSyntaxException(Exception exception, int excId, String command) {

                System.out.println("[DefaultScriptingScript-launchSyntaxException] "+exception.getMessage()+" "+excId+" "+command);

                this.delegatedObservable.notifyObservers(new BaseScriptingNotifycation(this, excId, command, exception));

        }

        private void launchCompilingException(Exception exception, int excId, String command) {

                this.delegatedObservable.notifyObservers(new BaseScriptingNotifycation(this, excId, 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.setSaved(false);

        }

        public Object run(Object args[]) {

                try {

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

                } catch (NoSuchMethodException e) {

                        this.engine = null;

                        launchCompilingException(e,2,this.getId());

                        return null;

                } catch (Exception e) {

                        this.engine = null;

                        ScriptException e1;

                        if (e.getCause() instanceof PySyntaxError){

                                e1 = getScriptExceptionFromPyException((ScriptException) e);

                        } else if(e.getCause() instanceof MissingMethodException){

                                MissingMethodException mme = (MissingMethodException)e.getCause().getCause();                                        

                                e1 = new ScriptException(mme.getMessage(),this.getId(),-1, -1);

                        }

                        else if(e.getCause() instanceof MultipleCompilationErrorsException){

                                MultipleCompilationErrorsException mcee= (MultipleCompilationErrorsException)e.getCause();

                                e1 = new ScriptException(mcee.getMessage(),this.getId(),-1, -1);        

                        }

                        else {

                                if(e instanceof ScriptException){

                                        e1 = (ScriptException) e;

                                }else{

                                        e1 = new ScriptException("Runtime exception");

                                }

                        }

                        launchSyntaxException(e1,1,"invoke");

                        e.printStackTrace();

                        return null;

                }

        }

        private ScriptException getScriptExceptionFromPyException(ScriptException e){

                PySyntaxError syntaxError = (PySyntaxError)e.getCause();

                String message = syntaxError.value.__getitem__(0)+" ";

                //String filename = syntaxError.value.__getitem__(1).__getitem__(3).toString();

                String line = syntaxError.value.__getitem__(1).__getitem__(1).toString();

                String column = syntaxError.value.__getitem__(1).__getitem__(2).toString();

                int l = Integer.parseInt(line);

                int c = Integer.parseInt(column);

                return new ScriptException(message,this.getId(),l, c);

        }

        protected Invocable getEngine(){

                if(this.engine == null){

                        this.engine = (Invocable) this.manager.getEngine(this.langName);

                        String code = this.getCode();

                        ScriptEngine scriptEngine = (ScriptEngine)this.engine;

                        scriptEngine.put("script", this);

                        try {

                                scriptEngine.eval(code);

                        } catch (ScriptException e) {

                                ScriptException e1;

                                if (e.getCause() instanceof PySyntaxError){

                                        e1 = getScriptExceptionFromPyException(e);

                                } else if(e.getCause() instanceof MultipleCompilationErrorsException){

                                        MultipleCompilationErrorsException mcee= (MultipleCompilationErrorsException)e.getCause();

                                        e1 = new ScriptException(mcee.getMessage(),this.getId(),-1, -1);        

                                }

                                else if(e.getCause().getCause() instanceof MissingMethodException){

                                        MissingMethodException mme = (MissingMethodException)e.getCause().getCause();

                                        e1 = new ScriptException(mme.getMessage(),this.getId(),-1, -1);

                                }

                                else{

                                        e1 = e;

                                }

                                launchSyntaxException(e1,1,"eval");

                        }

                }

                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 código 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);

        }

        @Override

    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 Object invokeFunction(String name, Object args[]) throws NoSuchMethodException{

                Invocable engine = getEngine();

                try {

                        return engine.invokeFunction(name, args);

                } catch (ScriptException e) {

                        throw new RuntimeException(e);

                } catch (NoSuchMethodException e) {

                        throw e;

                }

        }

        public Object invokeMethod(Object obj, String name, Object[] args) throws NoSuchMethodException {

                Invocable engine = getEngine();

                try {

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

                } catch (ScriptException e) {

                        throw new RuntimeException(e);

                } catch (NoSuchMethodException e) {

                        throw e;

                }

        }

        public String getLangName() {

                return this.langName;

        }

        protected void setLangName(String langName) {

                this.langName = langName;

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

        }

        public String[] getIconNames() {

                return new String[]{"scripting_"+this.getLangName(), null};

        }

        public String getMainName() {

                return this.mainName;

        }

        public void setMainName(String mainName) {

                this.mainName = mainName;

        }

        public String getExtension() {

                return this.extension;

        }

        public void setExtension(String extension) {

                this.extension = extension;

        }

        public Object run() {

                return this.run(null);

        }

        public boolean isSaved() {

                return this.saved;

        }

        public void addObserver(Observer o) {

                this.delegatedObservable.addObserver(o);

        }

        public void deleteObserver(Observer o) {

                this.delegatedObservable.deleteObserver(o);

        }

        public void deleteObservers() {

                this.delegatedObservable.deleteObservers();

        }

}