Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import java.io.StringWriter;

import java.net.URI;

import java.util.ArrayList;

import org.gvsig.expressionevaluator.Grammar;

import org.gvsig.expressionevaluator.GrammarFactory;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.CodeBuilder;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.LexicalAnalyzer;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.expressionevaluator.Optimizer;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.expressionevaluator.SymbolTableFactory;

import org.gvsig.expressionevaluator.Compiler;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.expressionevaluator.GrammarSet;

import org.gvsig.expressionevaluator.ReprMethod;

import org.gvsig.expressionevaluator.impl.repr.ReprNull;

import org.gvsig.expressionevaluator.impl.repr.ReprObject;

import org.gvsig.expressionevaluator.spi.formatter.value.BaseFormatter;

import org.gvsig.tools.bookmarksandhistory.Bookmarks;

import org.gvsig.tools.bookmarksandhistory.History;

import org.gvsig.tools.bookmarksandhistory.impl.BaseBookmarks;

import org.gvsig.tools.bookmarksandhistory.impl.BaseHistory;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.gvsig.tools.script.Script;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public class DefaultExpressionEvaluatorManager implements ExpressionEvaluatorManager {

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

    private Double accuracy;

    private final Map<String,SymbolTableFactory>symbolTableFactories;

    private final Map<String,GrammarFactory> grammarFactories;

    private Bookmarks<Expression> bookmarks;

    private History<Expression> history;

    private SymbolTable inmutableSymbolTable;

    private ResourcesStorage scriptsResourcesStorage;

    private List<ClassLoader> loaders;

    private Formatter<ExpressionBuilder.Value> expressionBuilderFormatter;

    public DefaultExpressionEvaluatorManager() {

        this.symbolTableFactories = new HashMap<>();

        this.grammarFactories = new HashMap<>();

        this.loaders = new ArrayList<>();

        this.scriptsResourcesStorage = ResourcesStorage.EMPTY_RESOURCESSTORAGE;

        this.loaders.add(this.getClass().getClassLoader());

        this.expressionBuilderFormatter = new BaseFormatter();

    }

    @Override

    public SymbolTable getSymbolTable(String name) {

        if( name == null ) {

            return null;

        }

        SymbolTableFactory factory = this.symbolTableFactories.get(name.toUpperCase());

        if( factory == null ) {

            return null;

        }

        return factory.create();

    }

    @Override

    public Collection<SymbolTableFactory> getSymbolTableFactories() {

        return this.symbolTableFactories.values();

    }

    @Override

    public final void registerSymbolTable(SymbolTableFactory factory) {

        if( factory == null ) {

            throw new IllegalArgumentException("factory can't be null");

        }

        this.symbolTableFactories.put(factory.getName().toUpperCase(),factory);

        this.inmutableSymbolTable = null;

    }

    @Override

    public SymbolTable getInmutableSymbolTable() {

        if( this.inmutableSymbolTable==null ) {

            this.inmutableSymbolTable = new InmutableSymbolTable();

        }

        return this.inmutableSymbolTable;

    }

    @Override

    public Object evaluate(String source) {

        DefaultInterpreter interpreter = new DefaultInterpreter();

        DefaultCompiler compiler = new DefaultCompiler(this);

        Code code = compiler.compileExpression(source);

        return interpreter.run(code);

    }

    @Override

    public Object evaluate(SymbolTable symbolTable, String source) {

        DefaultInterpreter interpreter = new DefaultInterpreter();

        DefaultCompiler compiler = new DefaultCompiler(this);

        Code code = compiler.compileExpression(source);

        if( symbolTable!=null ) {

            interpreter.setSymbolTable(symbolTable);

        }

        return interpreter.run(code);

    }

    @Override

    public Object evaluate(SymbolTable symbolTable, Code code) {

        DefaultInterpreter interpreter = new DefaultInterpreter();

        if( symbolTable!=null ) {

            interpreter.setSymbolTable(symbolTable);

        }

        return interpreter.run(code);

    }

    @Override

    public String evaluateDynamicText(String source) {

        return evaluateDynamicText(null, source);

    }

    @Override

    public boolean isDynamicText(String source) {

        String[] sources = StringUtils.substringsBetween(source, "<%", "%>");

        if( ArrayUtils.isEmpty(sources) ) {

            return false;

        }

        return true;

    }

    @Override

    public String evaluateDynamicText(SymbolTable symbolTable, String source) {

        String[] sources = StringUtils.substringsBetween(source, "<%", "%>");

        if( ArrayUtils.isEmpty(sources) ) {

            return source;

        }

        String[] values = new String[sources.length];

        DefaultInterpreter interpreter = new DefaultInterpreter();

        if( symbolTable!=null ) {

            interpreter.setSymbolTable(symbolTable);

        }

        StringWriter writer = new StringWriter();

        interpreter.setWriter(writer);

        DefaultCompiler compiler = new DefaultCompiler(this);

        for (int i = 0; i < sources.length; i++) {

            String theSource = sources[i];

            if( StringUtils.startsWith(theSource, "=") ) {

                Code code = compiler.compileExpression(theSource.substring(1));

                Object value = interpreter.run(code);

                values[i] = Objects.toString(value, "");

            } else {

                Code code = compiler.compileExpression(theSource.substring(1));

                writer.getBuffer().setLength(0);

                interpreter.run(code);

                values[i] = writer.toString();

            }

            sources[i] = "<%"+sources[i]+"%>";

        }

        String output = StringUtils.replaceEach(source, sources, values);

        return output;

    }

    @Override

    public Code compile(String source) {

        Compiler compiler = this.createCompiler();

        return compiler.compileExpression(source);

    }

    @Override

    public Code compile(LexicalAnalyzer lex, String source) {

        Compiler compiler = this.createCompiler();

        compiler.setLexicalAnalyzer(lex);

        return compiler.compileExpression(source);

    }

    @Override

    public Code optimize(SymbolTable symbolTable, Code code) {

        Optimizer optimizer = this.createOptimizer();

        return optimizer.optimize(symbolTable, code);

    }

    @Override

    public MutableSymbolTable createSymbolTable() {

        DefaultSymbolTable theSymbolTable = new DefaultSymbolTable();

        return theSymbolTable;

    }

    public void populateSymbolTable(SymbolTable aSymbolTable) {

        for (SymbolTableFactory factory : this.getSymbolTableFactories() ) {

            try {

                if( factory.isAutoload() ) {

                    SymbolTable symbolTable = factory.create();

                    aSymbolTable.addSymbolTable(symbolTable);

                }

            } catch(Throwable th) {

                String factoryName = "Unknown";

                try {

                    factoryName = factory.getName();

                } catch(Throwable th2) {

                    // Do nothing

                }

                LOGGER.warn("Can't create symbol table '"+factoryName+"'.", th);

            }

        }

    }

    @Override

    public LexicalAnalyzer createLexicalAnalyzer() {

        return new SQLLexicalAnalyzer();

    }

    @Override

    public CodeBuilder createCodeBuilder() {

        return new DefaultCodeBuilder(this);

    }

    @Override

    public Compiler createCompiler() {

        DefaultCompiler compiler = new DefaultCompiler(this);

        this.populateGrammars(compiler);

        return  compiler;

    }

    @Override

    public Interpreter createInterpreter() {

        Interpreter interpreter = new DefaultInterpreter();

        interpreter.setResourcesStorage(this.scriptsResourcesStorage);

        return interpreter;

    }

    @Override

    public Double getAccuracy() {

        return this.accuracy;

    }

    @Override

    public void setAccuracy(Double accuracy) {

        this.accuracy = accuracy;

    }

    @Override

    public Expression createExpression() {

        DefaultExpression e = new DefaultExpression(this);

        return e;

    }

    @Override

    public ExpressionBuilder createExpressionBuilder() {

        ExpressionBuilder x = new DefaultExpressionBuilder(this);

        return x;

    }

    @Override

    public Optimizer createOptimizer() {

        Optimizer x = new DefaultOptimizer(this);

        return x;

    }

    @Override

    public void registerGrammar(GrammarFactory factory) {

        if( factory==null ) {

            throw new IllegalArgumentException("factory can't be null");

        }

        this.grammarFactories.put(factory.getName(), factory);

    }

    @Override

    public Collection<GrammarFactory> getGrammarFactories() {

        return this.grammarFactories.values();

    }

    public void populateGrammars(Compiler compiler) {

        GrammarSet grammarSet = compiler.getGrammars();

        for (GrammarFactory factory : this.getGrammarFactories() ) {

            if( factory.isAutoload() ) {

                Grammar grammar = factory.create();

                grammarSet.add(grammar);

            }

        }

    }

    @Override

    public Grammar createGrammar(String name) {

        DefaultGrammar grammar = new DefaultGrammar(name);

        return grammar;

    }

    @Override

    public Bookmarks<Expression> getBookmarks() {

        if( this.bookmarks==null ) {

            this.bookmarks = new BaseBookmarks<>();

        }

        return this.bookmarks;

    }

    @Override

    public History<Expression> getHistory() {

        if( this.history==null ) {

            this.history = new BaseHistory<>(20);

        }

        return this.history;

    }

    @Override

    public Script createScript(String name, String code, String languaje) {

        SimpleScript sc = new SimpleScript(this.createInterpreter(), name, code);

        return sc;

    }

    @Override

    public Script locateScript(String name) {

        return loadScript(this.scriptsResourcesStorage, name);

    }

    @Override

    public Script loadScript(final URI location) {

        ResourcesStorage.Resource res = null;

        try {

            if( location==null ) {

                return null;

            }

            String resourceName = FilenameUtils.getBaseName(location.getPath());

            res = ResourcesStorage.createResource(resourceName, location);

            if( res == null || !res.exists() ) {

                return null;

            }

            Script script = loadScript(res, resourceName);

            return script;

        } catch (Exception ex) {

            LOGGER.warn("Can't load script from URI.", ex);

            return null;

        } finally {

            IOUtils.closeQuietly(res);

        }

    }

    @Override

    public Script loadScript(ResourcesStorage storage, String name) {

        ResourcesStorage.Resource res = null;

        try {

            if( storage==null ) {

                return null;

            }

            res = storage.getResource(name);

            if( res == null || !res.exists() ) {

                return null;

            }

            Script script = loadScript(res, name);

            return script;

        } catch (Exception ex) {

            LOGGER.warn("Can't load script from resources storage.", ex);

            return null;

        } finally {

            IOUtils.closeQuietly(res);

        }

    }

    private static final Pattern RE_LANG = Pattern.compile(".*lang[:]\\s*([a-zA-Z_][a-zA-Z_0-9_]*).*");

    private static final Pattern RE_ENCODING = Pattern.compile(".*encoding[:]\\s*([a-zA-Z_][a-zA-Z0-9_-]*).*");

    private Script loadScript(ResourcesStorage.Resource res, String name) {

        try {

            if( res == null || !res.exists() ) {

                return null;

            }

            byte[] head_bytes = new byte[500];

            IOUtils.read(res.asInputStream(), head_bytes);

            IOUtils.closeQuietly(res);

            String head = new String(head_bytes);

            if( StringUtils.isEmpty(head) ) {

                return null;

            }

            head = StringUtils.split(head, "\n")[0];

            String lang = "cosa";

            String encoding = null;

            Matcher m = RE_LANG.matcher(head);

            if( m!=null && m.matches() && m.groupCount()==1 ) {

                String s = m.group(1);

                if( !StringUtils.isBlank(s) ) {

                    lang = s;

                }

            }

            m = RE_ENCODING.matcher(head);

            if( m!=null && m.matches() && m.groupCount()==1 ) {

                String s = m.group(1);

                if( !StringUtils.isBlank(s) ) {

                    encoding = s;

                }

            }

            String source;

            if( StringUtils.isBlank(encoding) ) {

                source = IOUtils.toString(res.asInputStream());

            } else {

                source = IOUtils.toString(res.asInputStream(), encoding);

            }

            Script script = this.createScript(name, source, lang);

            return script;

        } catch (Exception ex) {

            LOGGER.warn("Can't load script from resource.", ex);

            return null;

        } finally {

            IOUtils.closeQuietly(res);

        }

    }

    @Override

    public ResourcesStorage getScriptsResourcesStorage() {

        return this.scriptsResourcesStorage;

    }

    @Override

    public void setScriptsResourcesStorage(ResourcesStorage scriptsResourcesStorage) {

        this.scriptsResourcesStorage = scriptsResourcesStorage;

    }

    private final List<ReprMethod> reprMethods = new ArrayList<>();

    private final Map<Class,ReprMethod> reprMethodsCache = new HashMap<>();

    private final ReprMethod reprNull = new ReprNull();

    private final ReprMethod reprObject = new ReprObject();

    @Override

    public void addReprMethod(ReprMethod method) {

        this.reprMethods.add(method);

        this.reprMethodsCache.clear();

    }

    @Override

    public ReprMethod getReprMethod(Object value) {

        if( value == null ) {

            return this.reprNull;

        }

        ReprMethod method = this.reprMethodsCache.get(value.getClass());

        if( method!=null ) {

            return method;

        }

        for (ReprMethod theMethod : reprMethods) {

            if( theMethod.isApplicable(value) ) {

                this.reprMethodsCache.put(value.getClass(), theMethod);

                return theMethod;

            }

        }

        return this.reprObject;

    }

    @Override

    public void registerClassLoader(ClassLoader loader) {

      this.loaders.add(loader);

    }

    @Override

    public List<ClassLoader> getClassLoaders() {

      return Collections.unmodifiableList(loaders);

    }

    @Override

    public Formatter<ExpressionBuilder.Value> getExpressionBuilderFormatter() {

      return expressionBuilderFormatter;

    }

    @Override

    public void registerExpressionBuilderFormatter(Formatter<ExpressionBuilder.Value> formatter) {

      this.expressionBuilderFormatter = formatter;

    }

}