Examples with GroovityCompilerEvent com.disney.groovity.compile.GroovityCompilerEvent used on opensource projects

Example 1 with GroovityCompilerEvent

use of com.disney.groovity.compile.GroovityCompilerEvent in project groovity by disney.

the class Groovity method compileLoop.

@SuppressWarnings("rawtypes")
private void compileLoop(Map<String, Class<Script>> newScripts, Map<String, Long> newScriptDates, Map<String, File> deletedScripts, Map<String, Collection<String>> scriptDependencies, Map<String, Boolean> scriptInits, boolean force, boolean init, int numErrors, ConcurrentHashMap<String, Class> compilerTraits, GroovitySource... sources) {
    HashMap<String, GroovitySource> errorSources = new HashMap<>();
    for (GroovitySource source : sources) {
        try {
            GroovityCompilerEvent event = new GroovityCompilerEvent();
            event.setPath(source.getPath());
            event.setTime(System.currentTimeMillis());
            String name = getScriptName(source.getPath());
            String nameCaseFixed = fixCase(name);
            String className = name.replaceAll("_", "___").replaceAll("/", "_");
            // System.out.println("Compiling source "+source.getPath()+" "+name+" "+className);
            if (source.exists()) {
                if (scripts.containsKey(nameCaseFixed)) {
                    event.setChange(Change.update);
                } else {
                    event.setChange(Change.add);
                }
                if (!force) {
                    Long cur = scriptDates.get(nameCaseFixed);
                    // System.out.println("comparing "+cur+" to "+source.getLastModified()+" for "+name);
                    if (cur != null && cur.longValue() == source.getLastModified()) {
                        continue;
                    }
                }
                String sourceCode = null;
                try {
                    sourceCode = source.getSourceCode();
                    // code transformations pre-compile
                    TransformedSource transformed = GroovitySourceTransformer.transformSource(sourceCode);
                    sourceCode = transformed.source;
                    // groovy script compiler
                    long time1 = System.currentTimeMillis();
                    ArrayList<String> dependencies = new ArrayList<String>();
                    CompilerConfiguration compilerConfiguration = createCompilerConfiguration(transformed != null ? transformed.sourceLineNumbers : null, dependencies);
                    // a classloader only gets the traits that are available when it is created, so we make a copy
                    ConcurrentHashMap<String, Class> traitsCopy = new ConcurrentHashMap<>(compilerTraits);
                    GroovityClassLoader loader = getParentLoader() != null ? new GroovityClassLoader(source.getPath(), getParentLoader(), compilerConfiguration, this, cacheRefreshExecutor, traitsCopy) : new GroovityClassLoader(source.getPath(), Thread.currentThread().getContextClassLoader(), compilerConfiguration, this, cacheRefreshExecutor, traitsCopy);
                    CompilationUnit cu = new CompilationUnit(compilerConfiguration, null, loader);
                    SourceUnit su = new TransformedSourceUnit(className.concat(GROOVITY_SOURCE_EXTENSION), transformed, compilerConfiguration, loader, new ErrorCollector(compilerConfiguration));
                    // errorCollector.sourceUnit = su;
                    cu.addSource(su);
                    // Don't compile all or extra class files get generated!
                    cu.compile(Phases.CLASS_GENERATION);
                    @SuppressWarnings("unchecked") GroovyClass[] gcs = (GroovyClass[]) cu.getClasses().toArray(new GroovyClass[0]);
                    Class<Script> scriptClass = loadGroovyClassesAndFindScript(loader, gcs, compilerTraits, traitsCopy, traits);
                    if (scriptClass != null) {
                        long time2 = System.currentTimeMillis();
                        log.info("Compiled Groovy Script: ".concat(source.getPath()) + " in " + (time2 - time1));
                    } else {
                        log.severe("UHOH!!  Unable to find main class for " + source.getPath());
                    }
                    if (jarPhases != null && jarPhases.contains(GroovityPhase.RUNTIME)) {
                        storeClasses(source, gcs);
                    }
                    if (log.isLoggable(Level.FINE)) {
                        log.fine("Registering script class " + scriptClass.getName() + " for name " + name);
                    }
                    newScripts.put(name, scriptClass);
                    newScriptDates.put(name, source.getLastModified());
                    scriptDependencies.put(name, dependencies);
                    scriptInits.put(name, hasInit((GroovityClassLoader) scriptClass.getClassLoader()));
                    if (log.isLoggable(Level.FINE)) {
                        log.fine("Found dependencies " + dependencies + " for script " + name);
                    }
                } catch (Throwable th) {
                    errorSources.put(nameCaseFixed, source);
                    log.log(Level.FINE, "Error compiling " + source.getPath(), th);
                    if (sourceCode != null && log.isLoggable(Level.FINE)) {
                        log.fine("Source code in trouble: \n" + sourceCode);
                    }
                    event.setError(th);
                } finally {
                    compileEvents.put(nameCaseFixed, event);
                }
            } else {
                // remove from memory and disk
                if (jarDirectory != null) {
                    deletedScripts.put(name, getClassesFile(source));
                } else {
                    deletedScripts.put(name, null);
                }
                if (scripts.containsKey(nameCaseFixed)) {
                    event.setChange(Change.remove);
                    compileEvents.put(fixCase(name), event);
                }
            }
        } catch (Exception e) {
            log.log(Level.SEVERE, "Error compiling groovy " + source.getPath(), e);
        }
    }
    if (!errorSources.isEmpty()) {
        boolean retry = (numErrors == 0 || errorSources.size() < numErrors);
        if (!retry) {
            // let's check if the compiling set of traits is missing anything
            for (Map.Entry<String, Class> entry : traits.entrySet()) {
                if (!compilerTraits.containsKey(entry.getKey())) {
                    retry = true;
                    compilerTraits.put(entry.getKey(), entry.getValue());
                }
            }
        }
        if (retry) {
            if (log.isLoggable(Level.FINE)) {
                log.fine("Retrying error compile on " + errorSources.size());
            }
            // retry failed compiles after all the rest in case they just need to pick up traits
            compileLoop(newScripts, newScriptDates, deletedScripts, scriptDependencies, scriptInits, force, init, errorSources.size(), compilerTraits, errorSources.values().toArray(new GroovitySource[0]));
        }
    }
}

Example 2 with GroovityCompilerEvent

use of com.disney.groovity.compile.GroovityCompilerEvent in project groovity by disney.

the class Groovity method compile.

/**
 * Compare the timestamp of the source against an existing compiled version, only recompiling
 * if they do not match.  The force parameter is used to force a recompile regardless of dates.
 *
 * @param sources
 * @param force
 */
@SuppressWarnings("rawtypes")
protected void compile(boolean force, boolean init, ConcurrentHashMap<String, Class> compilerTraits, GroovitySource... sources) {
    // take multiple sources and compile as a set, only initing() classes once all are loaded
    HashMap<String, Class<Script>> newScripts = new HashMap<String, Class<Script>>();
    HashMap<String, Long> newScriptDates = new HashMap<String, Long>();
    HashMap<String, File> deletedScripts = new HashMap<String, File>();
    HashMap<String, Collection<String>> scriptDependencies = new HashMap<String, Collection<String>>();
    HashMap<String, Boolean> scriptInits = new HashMap<String, Boolean>();
    compileLoop(newScripts, newScriptDates, deletedScripts, scriptDependencies, scriptInits, force, init, 0, compilerTraits, sources);
    List<Class<Script>> toDestroy = new ArrayList<Class<Script>>();
    HashSet<String> sourceNames = new HashSet<>();
    for (GroovitySource source : sources) {
        sourceNames.add(getScriptName(source.getPath()));
    }
    List<String> sortedScripts = sortDependencies(scriptDependencies, scriptInits);
    // load order for dependencies!
    for (String scriptName : sortedScripts) {
        String scriptNameFixed = fixCase(scriptName);
        Class<Script> theClass = newScripts.get(scriptName);
        if (init) {
            initClass(theClass);
        }
        scriptDates.put(scriptNameFixed, newScriptDates.get(scriptName));
        Class<Script> oldClass = scripts.put(scriptNameFixed, theClass);
        if (listeners != null) {
            for (GroovityClassListener listener : listeners) {
                listener.scriptUpdated(this, scriptName, theClass);
            }
        }
        if (oldClass != null) {
            toDestroy.add(oldClass);
        } else if (embeddedScripts.containsKey(scriptNameFixed)) {
            toDestroy.add(embeddedScripts.get(scriptNameFixed));
        }
    }
    for (Map.Entry<String, File> deleted : deletedScripts.entrySet()) {
        String name = deleted.getKey();
        String nameCaseFixed = fixCase(name);
        Class<Script> oldClass = scripts.remove(nameCaseFixed);
        scriptDates.remove(nameCaseFixed);
        // notify listeners
        if (listeners != null) {
            for (GroovityClassListener listener : listeners) {
                listener.scriptDeleted(name);
            }
        }
        if (oldClass != null) {
            log.info("Deleting removed source " + name + " / class " + oldClass.getName());
            toDestroy.add(oldClass);
            Class<Script> embeddedClass = embeddedScripts.get(nameCaseFixed);
            if (embeddedClass != null && init) {
                initClass(embeddedClass);
                newScripts.put(nameCaseFixed, embeddedClass);
            }
        }
        if (deleted.getValue() != null) {
            deleted.getValue().delete();
        }
    }
    if (init) {
        // now destroy
        for (Class<Script> del : toDestroy) {
            ((GroovityClassLoader) del.getClassLoader()).destroy();
        }
        if (started.get()) {
            // now start new scripts
            newScripts.values().forEach(cls -> {
                startClass(cls);
            });
        }
    }
    Map<String, Throwable> errors = new LinkedHashMap<String, Throwable>();
    for (Entry<String, GroovityCompilerEvent> entry : getCompilerEvents().entrySet()) {
        if (entry.getValue().getError() != null) {
            if (sourceNames.contains(entry.getKey())) {
                errors.put(entry.getKey(), entry.getValue().getError());
            }
        }
    }
    if (errors.size() > 0) {
        StringBuilder messageBuilder = new StringBuilder(String.valueOf(errors.size())).append(" script");
        if (errors.size() > 1) {
            messageBuilder.append("s");
        }
        messageBuilder.append(" failed to compile");
        for (Entry<String, Throwable> entry : errors.entrySet()) {
            messageBuilder.append(LINE_SEPARATOR);
            messageBuilder.append(LINE_SEPARATOR);
            messageBuilder.append("Error compiling ").append(entry.getKey()).append(".grvt :");
            messageBuilder.append(LINE_SEPARATOR);
            messageBuilder.append(LINE_SEPARATOR);
            messageBuilder.append(entry.getValue().getMessage());
        }
        log.severe(messageBuilder.toString());
    }
}