Examples with GroovitySource com.disney.groovity.source.GroovitySource used on opensource projects

Example 1 with GroovitySource

use of com.disney.groovity.source.GroovitySource in project groovity by disney.

the class GroovityTestMojo method execute.

public void execute() throws MojoExecutionException, MojoFailureException {
    try {
        if (skip) {
            return;
        }
        getLog().info("STARTING Groovity test");
        populateSystemProperties();
        ClassLoader testLoader = createClassLoader(ClassLoaderScope.TEST);
        GroovityServletContainerBuilder builder = new GroovityServletContainerBuilder().setPort(Integer.valueOf(port)).setWebappDirectory(new File(project.getBasedir(), "src/main/webapp")).setClassLoader(testLoader);
        if (groovitySourceDirectory != null && groovitySourceDirectory.exists()) {
            builder.addSourceLocation(groovitySourceDirectory.toURI(), true);
        }
        if (groovityTestDirectory != null && groovityTestDirectory.exists()) {
            builder.addSourceLocation(groovityTestDirectory.toURI(), true);
        }
        if (sources != null) {
            for (File source : sources) {
                builder.addSourceLocation(source.toURI(), true);
            }
        }
        GroovityStatistics.reset();
        GroovityServletContainer container = builder.build();
        container.start();
        Groovity groovity = container.getGroovity();
        ArrayList<String> appSources = new ArrayList<String>();
        try {
            if (failOnError) {
                validateFactory(groovity);
            }
            if (skipTests) {
                return;
            }
            GroovitySourceLocator[] sourceLocators = groovity.getSourceLocators();
            for (GroovitySourceLocator locator : sourceLocators) {
                if (!interactive && ((FileGroovitySourceLocator) locator).getDirectory().equals(groovityTestDirectory)) {
                    if (path != null) {
                        String[] pathParts = path.split("\\s*,\\s*");
                        for (String pathPart : pathParts) {
                            container.run(pathPart);
                        }
                    } else {
                        for (GroovitySource source : locator) {
                            String scriptPath = source.getPath();
                            scriptPath = scriptPath.substring(0, scriptPath.lastIndexOf("."));
                            String scriptName = scriptPath.substring(scriptPath.lastIndexOf('/') + 1);
                            if (scriptName.startsWith("test")) {
                                container.run(scriptPath);
                            }
                        }
                    }
                }
                if (((FileGroovitySourceLocator) locator).getDirectory().equals(groovitySourceDirectory)) {
                    for (GroovitySource source : locator) {
                        appSources.add(source.getPath());
                    }
                }
            }
            if (interactive) {
                // in interactive mode we wait for instructions and compile each time to allow
                // real-time development
                container.enterConsole();
            }
        } finally {
            container.stop();
        }
        Map<String, CodeCoverage> coverageMap = new TreeMap<String, GroovityTestMojo.CodeCoverage>();
        Collection<Class<Script>> scriptClasses = groovity.getGroovityScriptClasses();
        for (Class<Script> sc : scriptClasses) {
            String sourcePath = groovity.getSourcePath(sc);
            if (appSources.contains(sourcePath)) {
                String scriptLabel = sourcePath.substring(0, sourcePath.length() - 5);
                CodeCoverage cc = new CodeCoverage(sc, scriptLabel);
                if (cc.isCoverable()) {
                    coverageMap.put(scriptLabel, cc);
                }
                for (Class<?> c : ((GroovityClassLoader) sc.getClassLoader()).getLoadedClasses()) {
                    if (!c.equals(sc) && !(Closure.class.isAssignableFrom(c)) && !c.isInterface()) {
                        String cname = getClassLabel(c);
                        int p = 0;
                        if ((p = cname.indexOf("$Trait")) > 0) {
                            cname = cname.substring(0, p);
                        }
                        String classLabel = scriptLabel + "->" + cname;
                        CodeCoverage icc = new CodeCoverage(c, classLabel);
                        if (icc.isCoverable()) {
                            coverageMap.put(classLabel, icc);
                        }
                    }
                }
            }
        }
        List<Statistics> stats = GroovityStatistics.getStatistics();
        for (Statistics stat : stats) {
            String sks = stat.key.toString();
            int dot = sks.indexOf(".");
            if (dot > 0) {
                String className = sks.substring(0, dot);
                String method = sks.substring(dot + 1);
                CodeCoverage cc = coverageMap.get(className);
                if (cc != null) {
                    if (method.equals("run()") && cc.runnable) {
                        cc.ran = true;
                    } else {
                        if (cc.methods.containsKey(method)) {
                            cc.methods.put(method, true);
                        }
                    }
                }
            }
        }
        Collection<CodeCoverage> ccs = coverageMap.values();
        double total = 0;
        for (CodeCoverage cc : ccs) {
            total += cc.getCoverage();
        }
        total /= ccs.size();
        getLog().info("TEST COVERAGE " + ((int) (100 * total)) + "% TOTAL");
        for (Entry<String, CodeCoverage> entry : coverageMap.entrySet()) {
            CodeCoverage cc = entry.getValue();
            double covered = cc.getCoverage();
            getLog().info(" " + ((int) (100 * covered)) + "% coverage for " + cc.label);
            if (covered < 1.0) {
                if (cc.runnable && !cc.ran) {
                    getLog().warn("   Script body did not run during tests");
                }
                List<String> uncovered = cc.getUncoveredMethods();
                if (!uncovered.isEmpty()) {
                    for (String m : cc.getUncoveredMethods()) {
                        getLog().warn("   " + m + " did not execute during tests");
                    }
                }
            }
        /*
				for(String m: cc.getCoveredMethods()) {
					getLog().info("   " + m + " executed during tests");
				}
				*/
        }
    } catch (MojoFailureException e) {
        throw e;
    } catch (Throwable e) {
        getLog().error("ERROR in Groovity test", e);
        throw new MojoFailureException(e.getMessage());
    }
}

Example 2 with GroovitySource

use of com.disney.groovity.source.GroovitySource 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 3 with GroovitySource

use of com.disney.groovity.source.GroovitySource in project groovity by disney.

the class Groovity method getChangedSources.

public List<GroovitySource> getChangedSources() {
    ArrayList<GroovitySource> changedSources = new ArrayList<GroovitySource>();
    if (sourceLocators != null) {
        ArrayList<String> currentScripts = new ArrayList<String>(((Map<String, Long>) scriptDates).keySet());
        for (GroovitySourceLocator sourceLocator : sourceLocators) {
            for (GroovitySource source : sourceLocator) {
                String key = fixCase(source.getPath());
                if (key.endsWith(GROOVITY_SOURCE_EXTENSION)) {
                    key = key.substring(0, key.length() - 5);
                }
                if (scriptDates.containsKey(key)) {
                    currentScripts.remove(key);
                    if (!source.exists() || source.getLastModified() != scriptDates.get(key)) {
                        changedSources.add(source);
                    }
                } else if (source.exists()) {
                    changedSources.add(source);
                }
            }
        }
        for (final String script : currentScripts) {
            // these have been deleted
            Class<Script> delClass = scripts.get(script);
            final String path = getSourcePath(delClass);
            changedSources.add(new GroovitySource() {

                public String getSourceCode() throws IOException {
                    return "";
                }

                public String getPath() {
                    return path;
                }

                public long getLastModified() {
                    return System.currentTimeMillis();
                }

                public boolean exists() {
                    return false;
                }
            });
        }
    }
    return changedSources;
}

Example 4 with GroovitySource

use of com.disney.groovity.source.GroovitySource 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());
    }
}

Example 5 with GroovitySource

use of com.disney.groovity.source.GroovitySource in project groovity by disney.

the class Groovity method compileAll.

/**
 * Compile all scripts known to the configured source locators
 *
 * @param force if true, recompile all sources, if false recompile only changed sources
 */
public void compileAll(boolean force, boolean init) {
    if (inCompile.compareAndSet(false, true)) {
        try {
            compileEvents.clear();
            List<GroovitySource> sources = new ArrayList<GroovitySource>();
            // track existing views so we can keep track of files that may have since been deleted
            HashSet<String> oldViews = new HashSet<String>(((Map<String, Class<Script>>) scripts).keySet());
            for (GroovitySourceLocator sourceLocator : sourceLocators) {
                for (GroovitySource source : sourceLocator) {
                    try {
                        Matcher matcher = sourcePattern.matcher(source.getPath());
                        if (matcher.matches()) {
                            String name = matcher.group(1);
                            oldViews.remove(fixCase(name));
                            sources.add(source);
                        }
                    } catch (Exception e) {
                        log.log(Level.SEVERE, "Unable to load source " + source.getPath(), e);
                    }
                }
            }
            // remaining values in oldViews correspond to deleted files IF they are not embedded
            for (String del : oldViews) {
                Class<Script> cgs = scripts.get(del);
                final String path = getSourcePath(cgs);
                try {
                    sources.add(new GroovitySource() {

                        public String getSourceCode() throws IOException {
                            return "";
                        }

                        public String getPath() {
                            return path;
                        }

                        public long getLastModified() {
                            return System.currentTimeMillis();
                        }

                        public boolean exists() {
                            return false;
                        }
                    });
                } catch (Exception e) {
                    log.log(Level.SEVERE, "Error deleting grvt " + del, e);
                }
            }
            compile(force, init, sources.toArray(new GroovitySource[0]));
        } finally {
            inCompile.set(false);
        }
    } else {
        throw new RuntimeException("Groovy compiler is already busy, please retry later");
    }
}